/* 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; }