void* corto_string_deserAllocElem(void *ptr, corto_string_deser_t *data) {
corto_collection t = corto_collection(data->allocUdata);
corto_int32 size = corto_type_sizeof(t->elementType);
void *result = NULL;
if (ptr) {
switch(t->kind) {
case CORTO_SEQUENCE: {
corto_objectseq *seq = ptr; /* Use random built-in sequence type */
seq->buffer = corto_realloc(seq->buffer, (data->current + 1) * size);
seq->length = data->current + 1;
ptr = seq->buffer;
memset(CORTO_OFFSET(ptr, size * data->current), 0, size);
}
case CORTO_ARRAY:
result = CORTO_OFFSET(ptr, size * data->current);
break;
case CORTO_LIST: {
corto_ll list = *(corto_ll*)ptr;
if (corto_collection_requiresAlloc(t->elementType)) {
result = corto_calloc(size);
corto_ll_append(list, result);
} else {
corto_ll_append(list, NULL);
result = corto_ll_getPtr(list, corto_ll_size(list) - 1);
}
break;
default:
break;
}
}
}
return result;
}
void* json_deser_allocElem(void *ptr, corto_collection t, corto_int32 i)
{
corto_int32 size = corto_type_sizeof(t->elementType);
void *result = NULL;
switch(t->kind) {
case CORTO_SEQUENCE: {
corto_objectseq *seq = ptr; /* Use random built-in sequence type */
seq->buffer = corto_realloc(seq->buffer, (i + 1) * size);
seq->length = i + 1;
ptr = seq->buffer;
memset(CORTO_OFFSET(ptr, size * i), 0, size);
}
case CORTO_ARRAY:
result = CORTO_OFFSET(ptr, size * i);
break;
case CORTO_LIST: {
corto_ll list = *(corto_ll*)ptr;
if (corto_collection_requiresAlloc(t->elementType)) {
result = corto_calloc(size);
corto_llAppend(list, result);
} else {
corto_llAppend(list, NULL);
result = corto_llGetPtr(list, corto_llSize(list) - 1);
}
break;
default:
break;
}
}
return result;
}
int dynamic_structMain(int argc, char *argv[]) {
/* Create a new struct */
corto_struct Point = corto_declareChild(root_o, "Point", corto_struct_o);
if (!Point) {
goto error;
}
/* Create x member */
corto_member x = corto_declareChild(Point, "x", corto_member_o);
if (!x) {
goto error;
}
if (!corto_checkState(x, CORTO_DEFINED)) {
corto_setref(&x->type, corto_int32_o);
if (corto_define(x)) {
goto error;
}
}
/* Create y member */
corto_member y = corto_declareChild(Point, "y", corto_member_o);
if (!y) {
goto error;
}
if (!corto_checkState(y, CORTO_DEFINED)) {
corto_setref(&y->type, corto_int32_o);
if (corto_define(y)) {
goto error;
}
}
/* Finalize struct */
if (corto_define(Point)) {
goto error;
}
/* Create an instance of Point */
corto_object p = corto_createChild(root_o, "p", Point);
if (!p) {
goto error;
}
*(corto_int32*)CORTO_OFFSET(p, x->offset) = 10;
*(corto_int32*)CORTO_OFFSET(p, y->offset) = 20;
printf("p = %s\n", corto_contentof(NULL, "text/corto", p));
return 0;
error:
corto_error("error: %s", corto_lasterr());
return -1;
}
corto_int16 _md_DocUpdate(md_Doc _this, corto_object o, corto_uint8 level, corto_string niceName) {
CORTO_UNUSED(_this);
if (!corto_updateBegin(_this)) {
if ((corto_typeof(corto_typeof(_this)) == (corto_type)corto_target_o) && !corto_owned(_this)) {
corto_setref(&((md_Doc)((md_Doc)CORTO_OFFSET(_this, ((corto_type)md_Doc_o)->size)))->o, o);
((md_Doc)((md_Doc)CORTO_OFFSET(_this, ((corto_type)md_Doc_o)->size)))->level = level;
corto_setstr(&((md_Doc)((md_Doc)CORTO_OFFSET(_this, ((corto_type)md_Doc_o)->size)))->niceName, niceName);
} else {
corto_setref(&((md_Doc)_this)->o, o);
((md_Doc)_this)->level = level;
corto_setstr(&((md_Doc)_this)->niceName, niceName);
}
corto_updateEnd(_this);
} else {
return -1;
}
return 0;
}
corto_int16 _corto_native_type__update(corto_native_type _this, const char * name, bool is_ptr) {
CORTO_UNUSED(_this);
if (!corto_update_begin(_this)) {
if ((corto_typeof(corto_typeof(_this)) == (corto_type)corto_target_o) && !corto_owned(_this)) {
corto_set_str(&((corto_native_type)((corto_native_type)CORTO_OFFSET(_this, ((corto_type)corto_native_type_o)->size)))->name, name);
((corto_native_type)((corto_native_type)CORTO_OFFSET(_this, ((corto_type)corto_native_type_o)->size)))->is_ptr = is_ptr;
} else {
corto_set_str(&((corto_native_type)_this)->name, name);
((corto_native_type)_this)->is_ptr = is_ptr;
}
if (corto_update_end(_this)) {
return -1;
}
} else {
return -1;
}
return 0;
}
static void* html_getDocMember(corto_object doc, corto_string member, htmlData_t *data) {
corto_member m = corto_interface_resolveMember(data->docClass, member);
void *result = NULL;
if (m) {
result = CORTO_OFFSET(doc, m->offset);
} else {
corto_critical("member description not found in doc class");
}
return result;
}
static
int16_t corto_fmt_ptr_toValue(
corto_fmt_opt *opt,
corto_value *v,
const void* ptr)
{
corto_type t = corto_type(*(corto_type*)CORTO_OFFSET(ptr, -sizeof(corto_type)));
*v = corto_value_mem((void*)ptr, t);
return 0;
}
/* Combined hasNext and next */
static corto_bool corto_iterator_next_array(void* iterator) {
iteratorType *iter = iterator;
corto_uint32 elementSize = iter->is.array.elementSize;
void *current = iter->current;
corto_bool result = FALSE;
current = CORTO_OFFSET(current, elementSize);
if (current < iter->is.array.max) {
iter->current = current;
result = TRUE;
}
return result;
}
corto_int16 corto_value_memberExpr(corto_value *val, corto_string member, corto_value *out) {
corto_type t = corto_value_typeof(val);
corto_object o = corto_value_objectof(val);
void *ptr = corto_value_ptrof(val);
corto_id tokens;
strncpy(tokens, member, sizeof(corto_id));
char *cur = tokens, *prev = tokens;
do {
if (cur && (cur = strchr(cur + 1, '.'))) *cur = '\0';
if (!corto_instanceof(corto_interface_o, t)) {
corto_seterr(
"cannot get member from a non-composite value (type is '%s')",
corto_fullpath(NULL, t));
goto error;
}
if (!strcmp(prev, "super")) {
if (!(t = (corto_type)corto_interface(t)->base)) {
corto_seterr("super unpexpected: interface '%s' does not have a base",
corto_fullpath(NULL, t));
goto error;
} else {
*out = corto_value_base(ptr, t);
}
} else {
corto_member m = corto_interface_resolveMember(t, prev);
if (!m) {
corto_seterr(
"unresolved member '%s' in type '%s'",
prev,
corto_fullpath(NULL, t));
goto error;
}
ptr = CORTO_OFFSET(ptr, m->offset);
t = m->type;
*out = corto_value_member(o, m, ptr);
}
prev = cur + 1;
} while (cur);
return 0;
error:
return -1;
}
corto_int16 _corto_delegate_bind(corto_function object) {
/* $begin(::corto::lang::delegate::bind) */
corto_object parent = corto_parentof(object);
if (corto_class_instanceof(corto_interface_o, corto_typeof(parent))) {
corto_interface type = corto_interface(corto_typeof(parent));
corto_id functionName;
corto_member m = NULL;
/* Get function name, lookup delegate, assign function */
corto_signatureName(corto_nameof(object), functionName);
if (corto_checkState(corto_type_o, CORTO_DEFINED) && (m = corto_interface_resolveMember(type, functionName)) &&
(m->type->kind == CORTO_COMPOSITE) && (corto_interface(m->type)->kind == CORTO_DELEGATE)) {
if (corto_delegate_instanceof(corto_delegate(m->type), object)) {
/* Bind instance of function is a method */
if (corto_procedure(corto_typeof(object))->kind == CORTO_METHOD) {
corto_setref(&((corto_delegatedata *) CORTO_OFFSET(parent, m->offset))->instance, parent);
}
/* Bind procedure */
corto_setref(&((corto_delegatedata *) CORTO_OFFSET(parent, m->offset))->procedure, object);
} else {
/* If there is a member that corresponds to a delegate but has a non matching
* signature, always report error */
corto_id id1, id2;
corto_error("member '%s' of delegate type '%s' does not match signature of '%s'",
corto_nameof(m), corto_fullname(m->type, id1), corto_fullname(object, id2));
goto error;
}
}
}
return 0;
error:
return -1;
/* $end */
}
static corto_equalityKind corto_collection_compareArrayWithList(corto_collection t, void *array, corto_uint32 elementSize, corto_ll list) {
corto_equalityKind result = CORTO_EQ;
corto_uint32 i=0;
corto_iter iter;
void *e1, *e2;
corto_type elementType = t->elementType;
iter = corto_ll_iter(list);
while(corto_iter_hasNext(&iter)) {
if (corto_collection_requiresAlloc(elementType)) {
e1 = corto_iter_next(&iter);
} else {
e1 = corto_iter_nextPtr(&iter);
}
e2 = CORTO_OFFSET(array, elementSize * i);
result = corto_ptr_compare(e2, elementType, e1);
if (result != CORTO_EQ) {
break;
}
i++;
}
return result;
}
int select_contentTypeMain(int argc, char *argv[]) {
/* Create a Point type, so we have something to serialize to JSON */
corto_struct Point = corto_declareChild(root_o, "Point", corto_struct_o);
if (!Point) {
goto error;
}
/* Create x member */
corto_member x = corto_declareChild(Point, "x", corto_member_o);
if (!x) {
goto error;
}
if (!corto_checkState(x, CORTO_DEFINED)) {
corto_setref(&x->type, corto_int32_o);
if (corto_define(x)) {
goto error;
}
}
/* Create y member */
corto_member y = corto_declareChild(Point, "y", corto_member_o);
if (!y) {
goto error;
}
if (!corto_checkState(y, CORTO_DEFINED)) {
corto_setref(&y->type, corto_int32_o);
if (corto_define(y)) {
goto error;
}
}
/* Finalize Point struct */
if (corto_define(Point)) {
goto error;
}
/* Create two instances of Point. */
corto_object p1 = corto_declareChild(root_o, "p1", Point);
if (!p1) {
goto error;
}
if (!corto_checkState(p1, CORTO_DEFINED)) {
*(corto_int32*)CORTO_OFFSET(p1, x->offset) = 10;
*(corto_int32*)CORTO_OFFSET(p1, y->offset) = 10;
if (corto_define(p1)) {
goto error;
}
}
corto_object p2 = corto_declareChild(root_o, "p2", Point);
if (!p2) {
goto error;
}
if (!corto_checkState(p2, CORTO_DEFINED)) {
*(corto_int32*)CORTO_OFFSET(p2, x->offset) = 20;
*(corto_int32*)CORTO_OFFSET(p2, y->offset) = 30;
if (corto_define(p2)) {
goto error;
}
}
/* Select all instances of type Point, get value in JSON */
corto_iter it;
corto_int16 ret = corto_select("/", "*")
.contentType("text/json")
.type("/Point")
.iter(&it);
if (ret) {
goto error;
}
while (corto_iterHasNext(&it)) {
corto_result *r = corto_iterNext(&it);
printf("id: %s, value: %s\n", r->id, corto_result_getText(r));
}
return 0;
error:
corto_error("error: %s", corto_lasterr());
return -1;
}
static corto_int16 json_deserComposite(void* p, corto_type t, JSON_Value *v)
{
corto_assert(t->kind == CORTO_COMPOSITE, "not deserializing composite");
if (json_value_get_type(v) != JSONObject) {
corto_seterr("expected object, got %s", json_valueTypeToString(v));
goto error;
}
JSON_Object* o = json_value_get_object(v);
size_t count = json_object_get_count(o);
size_t i;
corto_bool isUnion = corto_interface(t)->kind == CORTO_UNION;
corto_int32 discriminator = 0;
corto_member unionMember = NULL;
for (i = 0; i < count; i++) {
const char* memberName = json_object_get_name(o, i);
corto_member member_o;
if (!strcmp(memberName, "super")) {
JSON_Value* value = json_object_get_value(o, memberName);
if (json_deserItem(p, corto_type(corto_interface(t)->base), value)) {
goto error;
}
} else if (!strcmp(memberName, "_d") && isUnion) {
JSON_Value* value = json_object_get_value(o, memberName);
if (json_deserPrimitive(&discriminator, corto_union(t)->discriminator, value)) {
goto error;
}
unionMember = corto_union_findCase(t, discriminator);
if (!unionMember) {
corto_seterr("discriminator '%d' invalid for union '%s'",
discriminator, corto_fullpath(NULL, t));
}
} else {
member_o = corto_interface_resolveMember(t, (char*)memberName);
/* Ensure that we're not resolving members from a base type */
if (!member_o || (corto_parentof(member_o) != t)) {
corto_seterr(
"cannot find member '%s' in type '%s'",
memberName,
corto_fullpath(NULL, t));
goto error;
}
if (isUnion && (unionMember != member_o)) {
corto_seterr(
"member '%s' does not match discriminator '%d' (expected member '%s')",
memberName,
discriminator,
corto_idof(unionMember));
goto error;
} else if (isUnion) {
corto_int32 prev = *(corto_int32*)p;
if (prev != discriminator) {
corto_member prevMember = corto_union_findCase(t, prev);
corto_deinitp(CORTO_OFFSET(p, prevMember->offset), prevMember->type);
memset(CORTO_OFFSET(p, member_o->offset), 0, member_o->type->size);
}
*(corto_int32*)p = discriminator;
}
if (!json_deserMustSkip(member_o, p)) {
JSON_Value* value = json_object_get_value(o, memberName);
void *offset = CORTO_OFFSET(p, member_o->offset);
if (member_o->modifiers & CORTO_OBSERVABLE) {
offset = *(void**)offset;
if (json_deserType(offset, member_o->type, value)) {
goto error;
}
} else {
if (member_o->modifiers & CORTO_OPTIONAL) {
if (*(void**)offset) {
corto_deinitp(*(void**)offset, member_o->type);
memset(*(void**)offset, 0, member_o->type->size);
} else {
*(void**)offset = corto_calloc(member_o->type->size);
}
offset = *(void**)offset;
}
if (json_deserItem(offset, member_o->type, value)) {
goto error;
}
}
}
}
}
return 0;
error:
return -1;
}