static void corto_lasterrorFree(void* tls) {
if (tls) {
if (((corto_errThreadData*)tls)->lastError) {
corto_dealloc(((corto_errThreadData*)tls)->lastError);
}
corto_dealloc(tls);
}
}
corto_int16 json_deserialize(corto_value *v, corto_string s)
{
corto_assert(v != NULL, "NULL passed to json_deserialize");
char *json = s;
if ((json[0] != '{') && (json[1] != '[') && (json[0] != '[')) {
corto_asprintf(&json, "{\"value\": %s}", json);
}
JSON_Value *jsonValue = json_parse_string(json);
if (!jsonValue) {
corto_seterr("invalid JSON '%s'", json);
goto error;
}
corto_type type = corto_value_getType(v);
if (type->kind == CORTO_PRIMITIVE) {
JSON_Object* jsonObj = json_value_get_object(jsonValue);
if (!jsonObj) {
corto_seterr("json: invalid JSON for primitive value '%s'", json);
goto error;
}
JSON_Value *jsonValue = json_object_get_value(jsonObj, "value");
if (!jsonValue) {
corto_seterr("json: missing 'value' field for primitive value '%s'", json);
goto error;
}
}
if (json_deserialize_from_JSON_Value(v, jsonValue)) {
goto error;
}
if (json != s) {
corto_dealloc(json);
}
return 0;
error:
if (json != s) {
corto_dealloc(json);
}
if (jsonValue) {
json_value_free(jsonValue);
}
return -1;
}
corto_err corto_logv(corto_err kind, unsigned int level, char* fmt, va_list arg, FILE* f) {
char buff[CORTO_MAX_LOG + 1];
size_t n = 0;
corto_string alloc = NULL;
corto_string msg = buff;
va_list argcpy;
va_copy(argcpy, arg); /* Make copy of arglist in
* case vsnprintf needs to be called twice */
CORTO_UNUSED(level);
if ((n = (vsnprintf(buff, CORTO_MAX_LOG, fmt, arg) + 1)) > CORTO_MAX_LOG) {
alloc = corto_alloc(n + 2);
vsnprintf(alloc, n, fmt, argcpy);
msg = alloc;
}
n = strlen(msg);
strcat(msg, "\n");
n++;
if (f == stderr) {
fprintf(f, "%s%s%s", RED, msg, NORMAL);
} else {
fprintf(f, "%s", msg);
}
if (alloc) {
corto_dealloc(alloc);
}
return kind;
}
static corto_int16 html_copyFiles(htmlData_t *data) {
corto_string doc;
corto_asprintf(&doc, "%s/doc", CORTO_GEN_DOC_HTML_ETC);
corto_ll files = corto_opendir(doc);
if (!files) {
goto error;
}
corto_iter it = corto_llIter(files);
while (corto_iterHasNext(&it)) {
corto_string f = corto_iterNext(&it);
corto_id file;
sprintf(file, "%s/%s", doc, f);
if (corto_cp(file, data->output)) {
goto error;
}
}
corto_closedir(files);
corto_dealloc(doc);
return 0;
error:
return -1;
}
corto_string corto_buffer_str(corto_buffer *b) {
corto_string result = NULL;
if (b->elementCount) {
if (b->buf) {
result = corto_strdup(b->buf);
} else {
void *next = NULL;
corto_uint32 len = (b->elementCount - 1) * CORTO_BUFFER_ELEMENT_SIZE +
b->current->pos + 1;
corto_buffer_element *e = &b->firstElement;
result = corto_alloc(len);
corto_string ptr = result;
do {
memcpy(ptr, e->buf, e->pos);
ptr += e->pos;
next = e->next;
if (e != &b->firstElement) {
corto_dealloc(e);
}
} while ((e = next));
result[len - 1] = '\0';
}
} else {
result = NULL;
}
b->elementCount = 0;
return result;
}
static void CORTO_NAME_BINARYOP(string,add)(void* op1, void* op2, void* result) {
corto_uint32 len = strlen(*(corto_string*)op1) + strlen(*(corto_string*)op2);
if (*(corto_string*)result) {
corto_dealloc(*(corto_string*)result);
}
*(corto_string*)result = corto_alloc(len + 1);
sprintf(*(corto_string*)result, "%s%s", *(corto_string*)op1, *(corto_string*)op2);
}
/* Delete item */
void g_itemFree(g_item item) {
g_dependency dep;
/* Free onDeclared list */
if (item->onDeclared) {
while((dep = corto_llTakeFirst(item->onDeclared))) {
corto_dealloc(dep);
}
corto_llFree(item->onDeclared);
}
/* Free onDefined list */
if (item->onDefined) {
while((dep = corto_llTakeFirst(item->onDefined))) {
corto_dealloc(dep);
}
corto_llFree(item->onDefined);
}
corto_dealloc(item);
}
corto_void _test_OptionalStringApi_tc_strNotSet(
test_OptionalStringApi _this)
{
/* $begin(test/OptionalStringApi/tc_strNotSet) */
test_OptionalString *o = test_OptionalStringCreate(NotSet, "Bar");
corto_string str = test_OptionalStringStr(o);
test_assertstr(str, "{\"Bar\"}");
corto_dealloc(str);
/* $end */
}
corto_void _test_compositeApi_tc_str(
test_compositeApi _this)
{
/* $begin(test/compositeApi/tc_str) */
test_compositeType o = {10, 20};
corto_string str = test_compositeTypeStr(&o);
test_assert(!strcmp(str, "{10,20}"));
corto_dealloc(str);
/* $end */
}
corto_void _test_compositeUnionApi_tc_strDefault(
test_compositeUnionApi _this)
{
/* $begin(test/compositeUnionApi/tc_strDefault) */
test_compositeUnionType o;
o.d = 4; o.is.num = 20;
corto_string str = test_compositeUnionTypeStr(&o);
test_assertstr(str, "{4,0x14}");
corto_dealloc(str);
/* $end */
}
corto_void _test_compositeUnionApi_tc_str(
test_compositeUnionApi _this)
{
/* $begin(test/compositeUnionApi/tc_str) */
test_compositeUnionType o;
o.d = 0; o.is.num = 10;
corto_string str = test_compositeUnionTypeStr(&o);
test_assertstr(str, "{0,10}");
corto_dealloc(str);
/* $end */
}
void corto_buffer_reset(corto_buffer *b) {
if (b->elementCount && !b->buf) {
void *next = NULL;
corto_buffer_element *e = &b->firstElement;
do {
next = e->next;
if (e != &b->firstElement) {
corto_dealloc(e);
}
} while ((e = next));
}
*b = CORTO_BUFFER_INIT;
}
void corto_seterrv(char *fmt, va_list args) {
char *err = NULL;
if (fmt) {
corto_vasprintf(&err, fmt, args);
}
corto_setLasterror(err);
if (fmt && (CORTO_DEBUG_ENABLED || CORTO_OPERATIONAL)) {
if (CORTO_OPERATIONAL == 1) {
corto_error("error raised while starting up: %s", err);
} else if (CORTO_OPERATIONAL){
corto_error("error raised while shutting down: %s", err);
} else {
corto_error("debug: %s", err);
}
corto_backtrace(stderr);
}
corto_dealloc(err);
}
void corto_value_free(corto_value *v) {
corto_type t = NULL;
switch(v->kind) {
case CORTO_LITERAL:
case CORTO_VALUE:
case CORTO_MEM:
t = corto_value_typeof(v);
break;
default:
break;
}
if (t) {
void *ptr = corto_value_ptrof(v);
corto_ptr_deinit(ptr, t);
if (v->kind == CORTO_VALUE) {
if (ptr != (void*)&v->is.value.storage) {
corto_dealloc(ptr);
}
}
}
*v = corto_value_empty();
}
/* Free nodes from index */
int corto_string_deserWalkIndex(void* o, void* ctx) {
CORTO_UNUSED(ctx);
corto_dealloc(o);
return 1;
}
/* Find existing parts in the code that must not be overwritten. */
static corto_ll cdiff_parseLegacy(char *code) {
char *ptr = NULL;
corto_ll result = corto_ll_new();
ptr = code;
while((ptr = strchr(ptr, '$'))) {
cdiff_elemKind kind = CDIFF_TEXT;
if (!memcmp(ptr, "$begin", 6)) {
ptr += 6;
kind = CDIFF_FUNCTION_LEGACY;
} else if (!memcmp(ptr, "$header", 7)) {
ptr += 7;
} else {
ptr ++;
continue;
}
/* Find begin of identifier */
if (*ptr == '(') {
char *endptr;
/* Find end of identifier */
endptr = strstr(ptr, ") */");
if (endptr) {
corto_id identifier;
/* Copy identifier string */
*endptr = '\0';
endptr += 3;
if (strlen(ptr) >= sizeof(corto_id)) {
corto_seterr(
"%s: identifier of code-snippet exceeds %d characters", sizeof(corto_id));
goto error;
}
strcpy(identifier, ptr + 1);
ptr = endptr + 1;
/* Find $end */
endptr = strstr(ptr, "$end");
endptr -= 3; /* include comment begin token */
if (endptr) {
cdiff_elem* el;
corto_string src;
if (kind != CDIFF_TEXT) {
endptr[0] = '}';
endptr[1] = '\n';
endptr[2] = '\0';
endptr += 3;
} else {
endptr[0] = '\n';
endptr[1] = '\0';
endptr += 2;
}
src = corto_strdup(ptr);
if(strstr(src, "$begin")) {
corto_seterr("code-snippet '%s' contains nested $begin (did you forget an $end?)",
identifier);
corto_dealloc(src);
goto error;
}
el = corto_alloc(sizeof(cdiff_elem));
el->kind = kind;
el->id = corto_strdup(identifier);
el->header = NULL;
el->body = src;
corto_ll_append(result, el);
ptr = endptr + 1;
} else {
corto_warning("generator: missing $end after $begin(%s)", identifier);
}
} else {
corto_warning("generator: missing ')' after $begin/$header");
}
} else {
corto_warning("generator: missing '(' after $begin/$header");
}
}
return result;
error:
if (result) {
corto_ll_free(result);
}
printf("error!\n");
return NULL;
}
static void corto_setLasterror(char* err) {
corto_errThreadData *data = corto_getThreadData();
if (data->lastError) corto_dealloc(data->lastError);
data->lastError = err ? corto_strdup(err) : NULL;
}
/* Append a format string to a buffer */
static corto_bool corto_buffer_appendIntern(
corto_buffer *b,
corto_string str,
void *data,
corto_uint32 ___ (*copy)(char *dst, char *str, corto_int32 len, void *data))
{
corto_bool result = TRUE;
if (!str) {
return result;
}
corto_buffer_init(b);
corto_int32 spaceLeftInElement = corto_buffer_spaceLeftInCurrentElement(b);
corto_int32 spaceLeft = corto_buffer_spaceLeft(b);
/* Compute the memory required to add the string to the buffer */
corto_int32 memRequired = copy(
corto_buffer_ptr(b),
str,
(b->max && (spaceLeft < spaceLeftInElement)) ? spaceLeft : spaceLeftInElement + 1,
data);
if (b->max && (spaceLeft < memRequired)) {
result = FALSE;
}
/* If the string required more memory than was available in the element,
* grow the buffer */
else if (memRequired >= spaceLeftInElement) {
/* If writing to a user-provided buffer, the max is reached and append
* should return false. Otherwise, the buffer needs to grow with extra
* elements. */
b->current->pos += spaceLeftInElement;
if (!b->buf) {
/* If the extra required memory doesn't exceed the elementsize, grow
* a new element, vsnprintf into the element and then memmove to
* truncate the part that was already added to the previous
* element */
if (memRequired < CORTO_BUFFER_ELEMENT_SIZE) {
corto_buffer_grow(b);
corto_int32 len = 0;
if (b->max && (spaceLeft < CORTO_BUFFER_ELEMENT_SIZE)) {
len = spaceLeft;
result = FALSE;
} else {
len = memRequired - spaceLeftInElement;
}
copy(corto_buffer_ptr(b), str, CORTO_BUFFER_ELEMENT_SIZE, data);
memmove(
corto_buffer_ptr(b),
corto_buffer_ptr(b) + spaceLeftInElement,
len);
b->current->pos = len;
/* If the extra memory required exceeds the elementSize, allocate a
* temporary string that will hold the full value, then distribute
* the results over the new elements */
} else {
corto_string dst = corto_alloc(memRequired + 1);
char *ptr = dst + spaceLeftInElement;
corto_int32 memLeft = memRequired - spaceLeftInElement;
/* Copy entire string to heap memory */
copy(dst, str, memRequired + 1, data);
/* Copy string to elements */
while (memLeft > 0) {
corto_buffer_grow(b);
if (memLeft > CORTO_BUFFER_ELEMENT_SIZE) {
corto_buffer_copy(b, ptr, CORTO_BUFFER_ELEMENT_SIZE);
ptr += CORTO_BUFFER_ELEMENT_SIZE;
memLeft -= CORTO_BUFFER_ELEMENT_SIZE;
} else {
corto_buffer_copy(b, ptr, memLeft);
memLeft = 0;
}
}
corto_dealloc(dst);
}
} else {
result = FALSE;
}
} else {
b->current->pos += memRequired;
}
return result;
}
void dDDS_free(void* ptr) {
corto_dealloc(ptr);
}
static int html_walkDocChilds(corto_object o, void *userData) {
htmlData_t *data = userData;
corto_string description = doc_getDescriptionFromDoc(o, data);
corto_string text = doc_getTextFromDoc(o, data);
corto_string niceName = doc_getNiceNameFromDoc(o, data);
corto_object *docs = corto_alloc(sizeof(corto_object) * corto_scopeSize(o));
corto_id index;
corto_object stack[CORTO_MAX_SCOPE_DEPTH];
corto_object ptr = o;
corto_int32 sp = data->level;
corto_id link;
corto_bool noIndex = FALSE;
corto_id upper;
strcpy(upper, niceName);
corto_strupper(upper);
if (niceName[0] == '#') {
noIndex = TRUE;
niceName ++;
}
corto_string parentId = corto_idof(corto_parentof(o));
if (parentId[0] == '#') parentId++;
strcpy(link, parentId);
strcat(link, "_");
if (corto_idof(o)[0] == '#') {
strcat(link, corto_idof(o) + 1);
} else {
strcat(link, corto_idof(o));
}
/* If level is 0, parse heading as title */
if (!data->level) {
data->title = niceName;
} else {
/* Add index number to header */
index[0] = '\0';
if ((sp > 1) && !noIndex) {
while (--sp) {
stack[sp - 1] = ptr;
ptr = corto_parentof(ptr);
}
for (; sp < data->level - 1; sp ++) {
char num[15]; sprintf(num, "%d", doc_getIndexFromDoc(stack[sp], data));
strcat(index, num);
strcat(index, ".");
}
if (data->level > 2) {
index[strlen(index) - 1] = '\0';
}
strcat(index, " ");
}
if (data->level == 1) {
corto_buffer_append(&data->content, "<a name=\"%s\"></a>\n<p class=\"section\">%s</p>\n",
link,
niceName);
} else {
corto_buffer_append(&data->content,
"<a name=\"%s\"></a>\n<h%d>%s%s</h%d>\n",
link,
data->level,
index,
niceName,
data->level);
}
if (data->level < 3) {
corto_buffer_append(&data->index,
"<li class=\"index-h%d\" onclick=\"window.location='#%s'\">%s</li>\n",
data->level,
link,
data->level == 1 ? upper : niceName);
}
corto_buffer_append(&data->content, "<div class=\"indent\">\n");
if (description && strlen(description)) {
if (data->level < 3) {
corto_buffer_append(&data->content, "<p class=\"description\">%s</p>\n", description);
} else {
corto_buffer_append(&data->content, "<p>%s</p>\n", description);
}
}
corto_string parsedText = doc_parse(text);
corto_buffer_append(&data->content, "%s\n", parsedText);
corto_dealloc(parsedText);
}
/* Collect documents in order */
corto_objectseq seq = corto_scopeClaim(o);
corto_objectseqForeach(seq, doc) {
docs[doc_getIndexFromDoc(doc, data) - 1] = doc;
}
corto_scopeRelease(seq);
/* Walk documents in order */
data->level ++;
int i; for (i = 0; i < corto_scopeSize(o); i ++) {
if (!html_walkDocChilds(docs[i], userData)) {
goto error;
}
}
data->level --;
corto_buffer_append(&data->content, "</div>\n");
corto_dealloc(docs);
return 1;
error:
return 0;
}
corto_int16 cortotool_publish(int argc, char *argv[]) {
corto_ll silent, mute, notag, dirs, majorarg, minorarg, patcharg;
corto_uint32 major = 0, minor = 0, patch = 0;
CORTO_UNUSED(argc);
corto_argdata *data = corto_argparse(
argv,
(corto_argdata[]){
{"$0", NULL, NULL}, /* Ignore 'publish' argument */
{"--silent", &silent, NULL},
{"--mute", &mute, NULL},
{"--notag", ¬ag, NULL},
{"$?*", &dirs, NULL},
{"$+major", &majorarg, NULL},
{"$|minor", &minorarg, NULL},
{"$|patch", &patcharg, NULL},
{NULL}
}
);
if (!data) {
corto_error("corto: %s", corto_lasterr());
goto error;
}
if (dirs) {
corto_string dir = corto_llGet(dirs, 0);
if (corto_chdir(dir)) {
corto_error("corto: %s", corto_lasterr());
goto error;
}
}
if (!corto_fileTest("./.corto")) {
corto_error("corto: invalid project directory");
goto error;
}
if (!notag) {
corto_error(
"corto: tagging of repository not yet supported "
"(use --notag to just increase version)");
goto error;
}
corto_string version = corto_fileLoad(".corto/version.txt");
/* Patch version */
if (version) {
char *v = version;
/* Parse major version */
char *ptr = strchr(version, '.');
if (ptr) {
*ptr = '\0';
major = atoi(v);
v = ptr + 1;
}
/* Parse minor version */
ptr = strchr(v, '.');
if (ptr) {
*ptr = '\0';
minor = atoi(v);
v = ptr + 1;
}
/* Parse patch version */
patch = atoi(v);
}
if (majorarg) {
major++;
}
if (minorarg) {
minor++;
}
if (patcharg) {
patch++;
}
FILE *f = fopen(".corto/version.txt", "w");
if (!f) {
corto_error("failed to open '.corto/version.txt' (check permissions)");
goto error;
}
fprintf(f, "%u.%u.%u\n", major, minor, patch);
fclose(f);
corto_argclean(data);
corto_dealloc(version);
if (!silent) {
corto_print("corto: version updated to %u.%u.%u", major, minor, patch);
}
return 0;
error:
return -1;
}
void release(corto_iter *it) {
corto_dealloc(it->udata);
}
void corto_llIterRelease(corto_iter *iter) {
corto_dealloc(iter->udata);
iter->udata = NULL;
}