md_Doc _md_DocDeclare(void) {
md_Doc _this;
_this = md_Doc(corto_declare(md_Doc_o));
if (!_this) {
return NULL;
}
return _this;
}
corto_native_type _corto_native_type__create(corto_object _parent, const char *_id, const char * name, bool is_ptr) {
corto_native_type _this;
_this = (corto_native_type)corto_declare(_parent, _id, corto_native_type_o);
if (!_this) {
return NULL;
}
if (!corto_check_state(_this, CORTO_VALID)) {
corto_set_str(&((corto_native_type)_this)->name, name);
((corto_native_type)_this)->is_ptr = is_ptr;
if (corto_define(_this)) {
corto_release(_this);
_this = NULL;
}
}
return _this;
}
md_Doc _md_DocCreate(corto_object o, corto_uint8 level, corto_string niceName) {
md_Doc _this;
_this = md_Doc(corto_declare(md_Doc_o));
if (!_this) {
return NULL;
}
if (!corto_checkState(_this, CORTO_DEFINED)) {
corto_setref(&((md_Doc)_this)->o, o);
((md_Doc)_this)->level = level;
corto_setstr(&((md_Doc)_this)->niceName, niceName);
if (corto_define(_this)) {
corto_release(_this);
_this = NULL;
}
}
return _this;
}
/* Deserialize string in object */
corto_string corto_string_deser(corto_string str, corto_string_deser_t* data) {
corto_char *ptr;
corto_bool createdNew = FALSE;
{
corto_id buffer;
corto_char *bptr, ch;
/* Parse typename that potentially precedes string */
bptr = buffer;
ptr = str;
while((ch = *ptr) && (ch != '{')) {
if (!((ch == ' ') || (ch == '\n') || (ch == '\t'))) {
*bptr = ch;
bptr++;
}
ptr++;
}
*bptr = '\0';
/* If no type is found, reset ptr */
if ((ch != '{') || (ptr == str)) {
ptr = str;
} else {
corto_object type;
/* If no out is provided create an object of the specified type */
if ((bptr != buffer)) {
type = corto_resolve(NULL, buffer);
if (type) {
if (data->type && (type != data->type)) {
corto_seterr(
"type of object ('%s') does not match string ('%s')",
corto_fullpath(NULL, data->type),
corto_fullpath(NULL, type));
corto_release(type);
goto error;
}
if (corto_instanceof(corto_type(corto_type_o), type)) {
if (!data->out) {
data->out = corto_declare(type);
createdNew = TRUE;
}
data->type = type;
} else {
corto_seterr("'%s' is not a type", buffer);
corto_release(type);
goto error;
}
corto_release(type);
} else {
corto_seterr("unknown type '%s'", buffer);
goto error;
}
} else {
type = data->type;
}
if (type && (corto_type(type)->kind == CORTO_PRIMITIVE)) {
ptr++;
}
}
}
data->current = 0;
data->index = NULL;
data->ptr = data->out;
data->anonymousObjects = NULL;
data->allocValue = NULL;
data->allocUdata = NULL;
if (data->out && data->isObject) {
if (!data->type) {
data->type = corto_typeof(data->out);
} else if (!corto_instanceofType(corto_typeof(data->out), data->type)) {
corto_seterr("object '%s' of type '%s' is not an instance of type '%s'",
corto_fullpath(NULL, data->out),
corto_fullpath(NULL, corto_typeof(data->out)),
corto_fullpath(NULL, data->type));
goto error;
}
}
if (!data->type) {
corto_seterr("no type provided for '%s'", str);
goto error;
}
if (data->type->kind == CORTO_PRIMITIVE) {
ptr = corto_string_deserParse(ptr, NULL, data);
} else {
ptr = corto_string_deserParseScope(ptr, NULL, data);
if (ptr) {
ptr ++;
}
}
if (!ptr) {
if (!corto_lasterr()) {
corto_seterr("failed to deserialize '%s'", str);
} else {
corto_seterr("failed to deserialize '%s': %s", str, corto_lasterr());
}
goto error;
}
if (data->anonymousObjects) {
corto_ll_free(data->anonymousObjects);
}
return ptr;
error:
if (data->out) {
if (createdNew) {
corto_release(data->out);
}
data->out = NULL;
}
return NULL;
}
static corto_string corto_string_parseAnonymous(
corto_string str,
corto_string value,
struct corto_string_deserIndexInfo *info,
corto_string_deser_t *data)
{
corto_object o = NULL;
char *ptr = str;
char *valuePtr = value;
corto_uint32 index = 0;
void *offset;
if (corto_string_getDestinationPtr(info, data, &offset)) {
corto_seterr("%s: %s", str, corto_lasterr());
goto error;
}
/* Check if this is a 'named' anonymous object in which case it is
* prefixed with <[id]> */
if ((valuePtr = corto_string_deserParseAnonymousId(valuePtr, &index))) {
if (data->anonymousObjects && (index <= corto_ll_size(data->anonymousObjects))) {
if (!*valuePtr) {
o = corto_ll_get(data->anonymousObjects, index - 1);
corto_claim(o);
} else {
/* If the <n> is followed up with more data, a new anonymous
* object is being created while one existed already with the
* specified number */
corto_seterr("identifier <%d> is already defined (%s)", index, value);
goto error;
}
}
} else {
valuePtr = value;
}
/* If no object has been referenced, create an anonymous object */
if (!o && *valuePtr) {
corto_object type = corto_resolve(NULL, valuePtr);
if (!type) {
corto_seterr("unresolved type '%s'", valuePtr);
goto error;
}
if (offset) {
o = *(corto_object*)offset;
if (!o || (type != corto_typeof(o))) {
if (!corto_instanceof(corto_type_o, type)) {
corto_seterr("'%s' is not a type", corto_fullpath(NULL, type));
goto error;
}
o = corto_declare(type);
if (!o) {
corto_seterr("failed to declare %s: %s",
value,
corto_lasterr());
goto error;
}
} else {
corto_claim(o);
}
}
corto_string_deser_t privateData = {
.out = data->out, // Preserve original out to determine ownership
.ptr = o,
.type = type,
.anonymousObjects = data->anonymousObjects,
.scope = data->scope,
.isObject = data->isObject
};
if (corto_type(type)->kind == CORTO_PRIMITIVE) {
ptr ++;
if (!(ptr = corto_string_deserParse(ptr, NULL, &privateData))) {
goto error;
}
} else {
if (!(ptr = corto_string_deserParseScope(ptr, NULL, &privateData))) {
goto error;
}
}
if (o) {
if (corto_define(o)) {
goto error;
}
data->anonymousObjects = privateData.anonymousObjects;
if (!data->anonymousObjects) {
data->anonymousObjects = corto_ll_new();
}
corto_ll_append(data->anonymousObjects, o);
}
}
if (offset) corto_ptr_setref(offset, o);
if (o) corto_release(o);
return ptr;
error:
if (o) corto_release(o);
return NULL;
}
