/* Create if statement based on ternary operator expressions */
ast_If ast_Ternary_createIf(ast_Expression condition, ast_Node ifTrue, ast_Node ifFalse) {
ast_Block trueBlock;
ast_Block falseBlock;
ast_If falseIf;
ast_If result;
if (corto_instanceof(corto_type(ast_Block_o), ifTrue)) {
trueBlock = ast_BlockCreate(yparser()->block);
falseBlock = ast_BlockCreate(yparser()->block);
ast_Block_addStatement(trueBlock, ast_Node(ifTrue));
ast_Block_addStatement(falseBlock, ast_Node(ifFalse));
ast_Parser_collect(yparser(), trueBlock);
ast_Parser_collect(yparser(), falseBlock);
} else {
trueBlock = ast_Block(ifTrue);
falseBlock = ast_Block(ifFalse);
}
falseIf = ast_IfCreate(NULL, falseBlock, NULL);
result = ast_IfCreate(condition, trueBlock, falseIf);
/* Because a ternary operator always has a true and false branch it there is not much use
* in reporting unreachable code. If a ternary operator has a compile-time resolvable
* condition, it is probably intended. */
ast_If_noWarnUnreachable(result);
ast_Parser_collect(yparser(), falseIf);
return result;
}
corto_int16 cpp_fluentTemplDecl(corto_type type, char *base, cpp_classWalk_t *data) {
corto_id id;
g_oid(data->g, type, id);
g_fileWrite(data->header, "// Helper class that sets members and enables inheritance for factories\n");
g_fileWrite(data->header, "template <class T>\n");
g_fileWrite(data->header, "class %s_v : public %s_v<T>\n", id, base);
g_fileWrite(data->header, "{\n");
g_fileWrite(data->header, "public:\n");
g_fileIndent(data->header);
g_fileWrite(data->header, "%s_v(T& _this, void *ptr) : %s_v<T>(_this, ptr) { }\n", id, base);
if (corto_instanceof(corto_interface_o, type) && corto_interface(type)->base) {
g_fileWrite(data->header, "%s_v<T> super() ", base);
g_fileWrite(data->header, "{ return %s_v<T>(this->m_this, this->ptr); }\n", base);
}
if (cpp_fluent_walkMembers(type, data)) {
goto error;
}
g_fileDedent(data->header);
g_fileWrite(data->header, "};\n");
g_fileWrite(data->header, "\n");
return 0;
error:
return -1;
}
corto_int16 json_deserReference(void* p, corto_type t, JSON_Value* v)
{
switch(json_value_get_type(v)) {
case JSONString: {
const char* reference = json_value_get_string(v);
corto_object o = corto_resolve(NULL, (corto_string)reference);
if (!o) {
corto_error("unresolved reference \"%s\"", reference);
goto error;
}
if (!corto_instanceof(t, o)) {
corto_error("%s is not an instance of %s", reference, corto_idof(t));
}
corto_setref(p, o);
corto_release(o);
break;
}
case JSONObject: {
JSON_Object* obj = json_value_get_object(v);
JSON_Value* type = json_object_get_value(obj, "type");
if (json_value_get_type(type) != JSONString) {
corto_seterr("type parameter of anonymous object must be a string");
goto error;
}
corto_type cortoType = corto_resolve(NULL, (char*)json_value_get_string(type));
if (!cortoType) {
corto_seterr("type '%s' not found for anonymous object", json_value_get_string(type));
goto error;
}
corto_object cortoObj = *(corto_object*)p;
if (!cortoObj || (corto_typeof(cortoObj) != cortoType)) {
cortoObj = corto_create(cortoType);
corto_setref(p, cortoObj);
corto_release(cortoObj);
}
corto_release(cortoType);
JSON_Value* value = json_object_get_value(obj, "value");
if (json_deserType(cortoObj, cortoType, value)) {
goto error;
}
break;
}
case JSONNull:
corto_setref(p, NULL);
break;
default:
corto_seterr("expected string, null or object (reference), got %s", json_valueTypeToString(v));
break;
}
return 0;
error:
return -1;
}
int corto_routerimpl_countArgs(corto_object o, void *userData) {
if (corto_instanceof(corto_route_o, o)) {
if (corto_routerimpl(userData)->maxArgs < corto_function(o)->parameters.length) {
corto_routerimpl(userData)->maxArgs = corto_function(o)->parameters.length;
}
}
return 1;
}
corto_bool json_deserMustSkip(corto_member m, void *ptr)
{
if (corto_instanceof(corto_target_o, corto_parentof(m))) {
corto_bool owned = corto_owned(ptr);
corto_bool isActual = !strcmp("actual", corto_idof(m));
if ((owned && !isActual) || (!owned && isActual)) {
return TRUE;
}
}
return FALSE;
}
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;
}
void* _dDDS_getEntity(corto_object o, corto_type type) {
void* result = NULL;
if (o && corto_instanceof(type, o)) {
result = corto_olsGet(o, DDDS_ENTITY_HANDLE);
if (!result) {
corto_seterr("%s contains an invalid handle",
corto_fullpath(NULL, o));
}
} else {
corto_seterr("%s is not of type %s",
corto_fullpath(NULL, o),
corto_fullpath(NULL, type));
}
return result;
}
corto_object md_resolve(int level, corto_string name, corto_object *parent, md_parseData* data) {
corto_assert(level >= 1 && level <= 6, "Level must be between 1 and 6");
corto_object o = NULL, current = NULL;
corto_object previous = NULL;
if (level == 1) {
previous = data->destination;
} else {
corto_uint32 i = level - 1;
while (i && !(previous = md_Doc(data->headers[i]))) {
i--;
}
previous = data->headers[i];
}
if (previous == NULL) {
goto notFound;
}
if (corto_instanceof(md_Doc_o, previous)) {
current = md_Doc(previous)->o;
}
if (parent) {
*parent = previous;
}
if (current || (level == 1)) {
o = corto_resolve(current, name);
if (o == NULL) {
goto notFound;
}
if (!md_isAncestor(current, o)) {
o = NULL;
}
}
/* Clean up the lower levels of the doc hierarchy */
int i = 6;
do {
data->headers[i] = NULL;
} while (i-- > level);
return o;
notFound:
return NULL;
}
/* 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;
}