static c_type createKeyType( const c_char *name, c_array keyList) { c_base base; c_type foundType; c_char *typeName; c_char keyName[16]; c_long i, length, sres; c_array members; c_metaObject o; c_field field; if (keyList == NULL) { return NULL; } base = c_getBase(keyList); length = c_arraySize(keyList); if (length == 0) { return NULL; } o = c_metaDefine(c_metaObject(base),M_STRUCTURE); members = c_arrayNew(c_member_t(base),length); for (i=0;i<length;i++) { field = keyList[i]; assert(field != NULL); members[i] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER); sprintf(keyName,"field%d",i); c_specifier(members[i])->name = c_stringNew(base,keyName); c_specifier(members[i])->type = c_keep(c_fieldType(field)); } c_structure(o)->members = members; c_metaObject(o)->definedIn = c_metaObject(base); c_metaFinalize(o); #define KEY_NAME "<Key>" #define KEY_FORMAT "%s<Key>" if (name != NULL) { length = sizeof(KEY_NAME) + strlen(name); typeName = os_malloc(length); sres = snprintf(typeName,length,KEY_FORMAT,name); assert(sres == (length-1)); } else { assert(FALSE); length = 100; typeName = os_malloc(length); os_sprintf(typeName,PA_ADDRFMT KEY_NAME,(c_address)o); } #undef KEY_NAME #undef KEY_FORMAT foundType = c_type(c_metaBind(c_metaObject(base),typeName,o)); c_free(o); os_free(typeName); return foundType; }
static c_metaEquality c_metaNameCompare ( c_baseObject baseObject, c_metaFindCompareArg arg) { c_findArg farg = (c_findArg)arg; c_metaEquality equality = E_UNEQUAL; char *name; if (CQ_KIND_IN_MASK (baseObject, farg->metaFilter)) { if (CQ_KIND_IN_MASK (baseObject, CQ_SPECIFIERS)) { name = c_specifier(baseObject)->name; } else if (CQ_KIND_IN_MASK (baseObject, CQ_METAOBJECTS)) { name = c_metaObject(baseObject)->name; } else { return equality; } if (farg->metaFilter & CQ_CASEINSENSITIVE) { if (os_strcasecmp (name, (const char *)farg->name) == 0) { equality = E_EQUAL; } } else { if (strcmp (name, (const char *)farg->name) == 0) { equality = E_EQUAL; } } } return equality; }
/* * return the real type (typedef are resoved) for a key (from a keylist). * scope should be the data type. */ static c_type idl_getTypeOfKey( c_type scope, os_char* keyName) { c_iter fields = NULL; c_specifier sp; char *fieldName; /* Key field name consists of [<field>.]*<field> */ fields = c_splitString(keyName, "."); fieldName = c_iterTakeFirst(fields); /* find specificer (sp) corresponding to keylist field name */ while (fieldName != NULL) { if (scope) { sp = c_specifier(c_metaFindByName(c_metaObject(scope), fieldName, CQ_FIXEDSCOPE | CQ_MEMBER | CQ_CASEINSENSITIVE)); assert(sp && (strcmp(sp->name, fieldName) == 0)); scope = sp->type; } fieldName = c_iterTakeFirst(fields); } /* now scope is type of key. But it can be typedef. Determine the actual type. */ return c_typeActualType(scope); }
c_iter c_bindMembers( c_metaObject scope, c_iter declarations, c_type type) { c_iter members; c_baseObject o; c_declarator d; members = NULL; d = c_iterTakeFirst(declarations); while (d != NULL) { o = c_metaDefine(scope,M_MEMBER); c_specifier(o)->name = d->name; c_specifier(o)->type = c_declaratorType(d,type); members = c_iterInsert(members,o); os_free(d); d = c_iterTakeFirst(declarations); } c_iterFree(declarations); return members; }
c_unionCase c_unionCaseNew ( c_metaObject scope, const c_char *name, c_type type, c_iter labels) { c_unionCase o; c_ulong nrOfLabels; c_type subType; nrOfLabels = c_iterLength(labels); o = c_unionCase(c_metaDefine(scope,M_UNIONCASE)); subType = c_type(c_metaResolve(scope,"c_literal")); o->labels = c_arrayNew(subType,nrOfLabels); c_free(subType); c_iterArray(labels,o->labels); c_specifier(o)->name = c_stringNew(c__getBase(scope),name); /* Do not keep type as usage expects transferral of refcount. * If changed then odlpp and idlpp must be adapted accordingly. */ c_specifier(o)->type = type; return o; }
static c_bool idl_unionHasCase(c_union _union, char *name) { c_long caseCount, i; c_unionCase _case; c_bool result = FALSE; caseCount = c_arraySize(_union->cases); for(i=0; i<caseCount; i++) { _case = _union->cases[i]; if(!strcmp(c_specifier(_case)->name, name)) { result = TRUE; break; } } return result; }
static void extractStructReferences( c_structure m, c_object o, void *data) { c_long i,length; c_member member; c_type type; c_object *ref; if (m->references == NULL) return; length = c_arraySize(m->references); for (i=0;i<length;i++) { member = c_member(m->references[i]); type = c_typeActualType(c_specifier(member)->type); while (c_baseObject(type)->kind == M_TYPEDEF) { type = c_typeDef(type)->alias; } switch (c_baseObject(type)->kind) { case M_CLASS: case M_INTERFACE: case M_COLLECTION: case M_BASE: ref = C_DISPLACE(data,member->offset); *ref = NULL; c_copyOut(type,C_REFGET(o,member->offset),ref); break; case M_EXCEPTION: case M_STRUCTURE: case M_UNION: copyReferences(type,C_DISPLACE(o,member->offset), C_DISPLACE(data,member->offset)) ; break; default: assert(FALSE); break; } } }
os_int32 idl_stacDefFindMemberIndexByName( c_array members, const os_char* name) { os_uint32 membersSize; os_int32 memberIndex = -1; c_member member; os_uint32 i; membersSize = c_arraySize(members); for(i = 0; i < membersSize && memberIndex == -1 ; i++) { member = c_member(members[i]); if(0 == strcmp(c_specifier(member)->name, name)) { memberIndex = (os_int32) i; } } return memberIndex; }
c_field c_fieldNew ( c_type type, const c_char *fieldName) { c_array path; c_field field; c_metaObject o; c_long n,length; c_address offset; c_iter nameList, refsList; c_string name; c_base base; if ((fieldName == NULL) || (type == NULL)) { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "illegal parameter"); return NULL; } base = c__getBase(type); if (base == NULL) { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to retreive base"); return NULL; } nameList = c_splitString(fieldName,"."); length = c_iterLength(nameList); field = NULL; if (length > 0) { o = NULL; offset = 0; refsList = NULL; path = c_newArray(c_fieldPath_t(base),length); if (path) { for (n=0;n<length;n++) { name = c_iterTakeFirst(nameList); o = c_metaResolve(c_metaObject(type),name); os_free(name); if (o == NULL) { c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); c_iterFree(refsList); c_free(path); return NULL; } path[n] = o; switch (c_baseObject(o)->kind) { case M_ATTRIBUTE: case M_RELATION: type = c_property(o)->type; offset += c_property(o)->offset; break; case M_MEMBER: type = c_specifier(o)->type; offset += c_member(o)->offset; break; default: c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); c_iterFree(refsList); c_free(path); return NULL; } switch (c_baseObject(type)->kind) { case M_INTERFACE: case M_CLASS: case M_COLLECTION: /*Longs are inserted in an iterator? Explanation please...*/ refsList = c_iterInsert(refsList,(c_voidp)offset); offset = 0; break; default: break; } } if (offset > 0) { refsList = c_iterInsert(refsList,(c_voidp)offset); } field = c_new(c_field_t(base)); field->name = c_stringNew(base,fieldName); field->path = path; field->type = c_keep(type); field->kind = c_metaValueKind(o); field->refs = NULL; if (refsList) { length = c_iterLength(refsList); field->offset = 0; if (length > 0) { field->refs = c_newArray(c_fieldRefs_t(base),length); if (field->refs) { for (n=(length-1);n>=0;n--) { field->refs[n] = c_iterTakeFirst(refsList); } } else { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to allocate field->refs array"); c_free(field); field = NULL; } } c_iterFree(refsList); } else { field->offset = offset; } } else { OS_REPORT(OS_ERROR, "c_fieldNew failed",0, "failed to allocate field->path array"); c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL); c_iterFree(nameList); } c_iterFree(nameList); } else { OS_REPORT_1(OS_ERROR, "c_fieldNew failed",0, "failed to process field name <%s>", fieldName); } return field; }
static void c_deepwalkUnion( c_union v_union, c_object *objectPtr, c_deepwalkFunc action, void *actionArg) { c_type switchType; c_type caseType; c_unionCase deflt; c_unionCase activeCase; c_unionCase currentCase; c_object unionData; c_value switchValue; c_literal label; int i,j, nCases, nLabels; c_long dataOffset; /* action for the union itself */ /* No action, but separate actions for the switch and the data */ /* action(c_type(v_union), objectPtr, actionArg); */ /* action for the switch */ c_deepwalkType(v_union->switchType, objectPtr, action, actionArg); switchType = c_typeActualType(v_union->switchType); /* Determine value of the switch field */ switch (c_baseObject(switchType)->kind) { case M_PRIMITIVE: switch (c_primitive(switchType)->kind) { #define __CASE__(prim, type) \ case prim: switchValue = type##Value(*((type *)*objectPtr)); break; __CASE__(P_BOOLEAN,c_bool) __CASE__(P_CHAR,c_char) __CASE__(P_SHORT,c_short) __CASE__(P_USHORT,c_ushort) __CASE__(P_LONG,c_long) __CASE__(P_ULONG,c_ulong) __CASE__(P_LONGLONG,c_longlong) __CASE__(P_ULONGLONG,c_ulonglong) #undef __CASE__ default: switchValue = c_undefinedValue(); assert(FALSE); break; } break; case M_ENUMERATION: switchValue = c_longValue(*(c_long *)*objectPtr); break; default: switchValue = c_undefinedValue(); assert(FALSE); break; } /* Determine the label corresponding to this field */ activeCase = NULL; deflt = NULL; nCases = c_arraySize(v_union->cases); for (i=0; (i<nCases) && !activeCase; i++) { currentCase = c_unionCase(v_union->cases[i]); nLabels = c_arraySize(currentCase->labels); if (nLabels > 0) { for (j=0; (j<nLabels) && !activeCase; j++) { label = c_literal(currentCase->labels[j]); if (c_valueCompare(switchValue, label->value) == C_EQ) { activeCase = currentCase; } } } else { deflt = currentCase; } } if (!activeCase) { activeCase = deflt; } assert(activeCase); if (activeCase) { caseType = c_specifier(activeCase)->type; if (c_type(v_union)->alignment >= v_union->switchType->size) { dataOffset = c_type(v_union)->alignment; } else { dataOffset = v_union->switchType->size; } unionData = C_DISPLACE(*objectPtr, (c_address)dataOffset); c_deepwalkType(caseType, &unionData, action, actionArg); } }
/* This operation scans through the list of items within the 'stac' pragma. * For each structure that is identified it will locate the corresponding * meta structure. It will then locate each member mentioned in the 'stac' * pragma within the member list of said meta structure. It will verify the * located member is indeed a character array. * It will then proceed to replace the meta data describing the located member * with new meta data with as goal to have the new meta data identify the member * as a string instead of as a character array. * All replaced meta data is stored in out variables to facilitate restore the * member list of the meta structure back into it's original configuration. * This operation is needed then the meta data of the found structure is * converted to XML. As the XML generation code is located in the database and * we do not want the database to get knowledge of the 'stac' pragma. */ c_iter idl_stacDefConvertAll( idl_stacDef stacDef) { os_uint32 size; os_uint32 i; idl_stacMap stacMapItem; c_structure structure; c_iter memberNames; os_uint32 memberNamesSize; os_uint32 j; os_char* memberName; os_int32 memberIndex; c_member member; c_member newMember; os_uint32* replacedIndex; idl_stacDefReplaceInfo replaceData; c_iter replaceInfo = NULL; c_base base; c_iter boundedStringToBeConverted; os_boolean stacCanBeApplied = OS_TRUE; os_boolean onlyExclusionlistings; if(stacDef) { /* Create collections to hold the original members and their respective * indexes in the member collection so we can easily restore the meta * structure to it's original configuration at a later time. */ replaceInfo = c_iterNew(NULL); size = c_iterLength (stacDef->stacList); for(i = 0; i < size; i++) { stacMapItem = c_iterObject (stacDef->stacList, i); /* find the matching structure in the meta data */ structure = idl_stacDefFindMetaStructureResolved( stacMapItem->scope, stacMapItem->typeName); assert(structure); replaceData = os_malloc(C_SIZEOF(idl_stacDefReplaceInfo)); replaceData->structure = structure; replaceData->replacedIndexes = c_iterNew(NULL); replaceData->replacedMembers = c_iterNew(NULL); memberNames = c_splitString(stacMapItem->stacList, ","); onlyExclusionlistings = idl_stacDefOnlyExclusionsDefined(stacMapItem->stacList); memberNamesSize = c_iterLength(memberNames); boundedStringToBeConverted = c_iterNew(NULL); if(memberNamesSize == 0 || onlyExclusionlistings) { os_uint32 membersSize; membersSize = c_arraySize(structure->members); for(j = 0; j < membersSize; j++) { member = c_member(structure->members[j]); memberName = c_specifier(member)->name; /* check if this member is in the list of member names when * the member names list contains exclusion listings */ if((onlyExclusionlistings && c_iterResolve(memberNames, idl_stacDefNamesAreEqual, memberName) == NULL) || memberNamesSize == 0) { stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_specifier(member)->type); if(stacCanBeApplied) { /* this is a bounded string, so we want to convert */ c_iterInsert(boundedStringToBeConverted, member); } } } } else { for(j = 0; j < memberNamesSize; j++) { memberName = c_iterTakeFirst(memberNames); if(memberName[0] == '!') { printf("FATAL ERROR | #pragma stac: Illegal syntax combination detected. " "The pragma stac definition for structure %s contains both normal " "member listings (without the '!' character in front of them) as " "well as exclusion member listings (with the '!' character in front " "of them). This has no relevant meaning, please see the deployment manual " "for information on usage of pragma stac.\n" "Ignoring the following member defintion: '%s'\n", c_metaScopedName(c_metaObject(structure)), memberName); exit(-2); } memberIndex = idl_stacDefFindMemberIndexByName( structure->members, memberName); if(memberIndex == -1) { printf("FATAL ERROR | #pragma stac: Unable to locate member %s " "within structure %s.\n", memberName, c_metaScopedName(c_metaObject(structure))); exit(-2); } member = structure->members[memberIndex]; /* Verify the member is a bounded string as required */ stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_specifier(member)->type); if(!stacCanBeApplied) { printf("FATAL ERROR | #pragma stac: Member %s within structure " "%s is not a bounded string (note: may be embedded within an array or sequence) as required.\n", memberName, c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } /* this is a bounded string, so we want to convert */ c_iterInsert(boundedStringToBeConverted, member); } } while(c_iterLength(boundedStringToBeConverted) > 0) { member = c_iterTakeFirst(boundedStringToBeConverted); memberIndex = idl_stacDefFindMemberIndexByName( structure->members, c_specifier(member)->name); assert(memberIndex != -1); newMember = c_metaDefine(c_metaObject(structure), M_MEMBER); base = c_getBase(member); c_specifier(newMember)->name = c_stringNew(base, c_specifier(member)->name); c_specifier(newMember)->type = idl_stacDefConvertStacApprovedMember(structure, c_specifier(member)->type); if(!c_specifier(newMember)->type) { printf("FATAL ERROR | #pragma stac: An internal error occured. Member %s within structure " "%s failed to convert from a bounded string to a character array.\n", c_specifier(newMember)->name, c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } structure->members[memberIndex] = newMember; c_iterInsert(replaceData->replacedMembers, member); replacedIndex = os_malloc(sizeof(os_uint32)); *replacedIndex = (os_uint32)memberIndex; c_iterInsert(replaceData->replacedIndexes, replacedIndex); } c_iterInsert(replaceInfo, replaceData); } } return replaceInfo; }
/* * Check if each usage of a char array as a key has a corresponding * "#pragma cats" declaration. */ static c_bool idl_checkCatsUsage( c_base base, const char* filename) { char errorBuffer [IDL_MAX_ERRORSIZE]; idl_keyDef keyDef = idl_keyDefDefGet(); c_long keyMapIdx; idl_keyMap keyMap; c_type type; c_structure structure; c_iter keysList; os_uint32 keysListSize; os_uint32 keyIdx; c_char* keyName; os_uint32 i; c_iter keyNameList; os_uint32 keyNameListSize; c_structure tmpStructure; c_specifier sp; c_type subType; c_string typeName; c_type spType; if (keyDef != NULL) { /* check all key definition list elements */ for (keyMapIdx = 0; keyMapIdx < c_iterLength(keyDef->keyList); keyMapIdx++) { keyMap = c_iterObject(keyDef->keyList, keyMapIdx); /* if a keylist is defined for the type */ if (keyMap->keyList && strlen(keyMap->keyList) > 0) { /* find meteobject for the type */ type = c_type(c_metaResolveType(keyMap->scope, keyMap->typeName)); if (!type) { snprintf(errorBuffer, IDL_MAX_ERRORSIZE-1, errorText[idl_UndeclaredIdentifier], keyMap->typeName); idl_printError(filename, errorBuffer); return OS_FALSE; } /* type can be a typedef. Determine the actual type. */ type = c_typeActualType(type); /* type should be a structure */ if (c_baseObject(type)->kind != M_STRUCTURE) { snprintf(errorBuffer, IDL_MAX_ERRORSIZE-1, errorText[idl_IllegalKeyFields]); idl_printError(filename, errorBuffer); return OS_FALSE; } structure = c_structure(type); /* for each key in keyList, check if type is a char array */ keysList = c_splitString(keyMap->keyList, ","); keysListSize = c_iterLength(keysList); for(keyIdx = 0; keyIdx < keysListSize; keyIdx++) { keyName = c_iterTakeFirst(keysList); /* We might be dealing with a field of a field definition in * the keylist, so let's split this up */ keyNameList = c_splitString(keyName, "."); keyNameListSize = c_iterLength(keyNameList); tmpStructure = structure; for(i = 0; i < keyNameListSize; i++) { keyName = c_iterTakeFirst(keyNameList); /* Now get the actual member defined by the name */ sp = c_specifier(c_metaFindByName( c_metaObject(tmpStructure), keyName, CQ_FIXEDSCOPE | CQ_MEMBER | CQ_CASEINSENSITIVE)); if(sp) { spType = c_typeActualType(sp->type); /* If the member is a structure, we need to * recurse deeper. */ if(c_baseObject(spType)->kind == M_STRUCTURE) { tmpStructure = c_structure(spType); } /* If the member is a collection then we need to * ensure it is not a character array, but if it * is we need to ensure a corresponding CATS pragma * can be located */ else if(c_baseObject(spType)->kind == M_COLLECTION && c_collectionType(spType)->kind == C_ARRAY) { subType = c_typeActualType(c_collectionType(spType)->subType); if(c_baseObject(subType)->kind == M_PRIMITIVE && c_primitive(subType)->kind == P_CHAR) { typeName = c_metaName(c_metaObject(tmpStructure)); /* check if there is corresponding catsDef */ if (!idl_isCatsDefFor(c_metaObject(tmpStructure)->definedIn, typeName, keyName)) { snprintf( errorBuffer, IDL_MAX_ERRORSIZE-1, errorText[idl_NoCorrespondingCats], c_metaObject(structure)->name, keyName); idl_printError(filename, errorBuffer); return OS_FALSE; } c_free(typeName); } } } } } } } } return OS_TRUE; }
static c_bool c__cloneReferences ( c_type type, c_voidp data, c_voidp dest) { c_type refType; c_class cls; c_array references, labels, ar, destar; c_sequence seq, destseq; c_property property; c_member member; c_long i,j,length,size; c_long nrOfRefs,nrOfLabs; c_value v; switch (c_baseObject(type)->kind) { case M_CLASS: cls = c_class(type); while (cls) { length = c_arraySize(c_interface(cls)->references); for (i=0;i<length;i++) { property = c_property(c_interface(cls)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } cls = cls->extends; } break; case M_INTERFACE: length = c_arraySize(c_interface(type)->references); for (i=0;i<length;i++) { property = c_property(c_interface(type)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } break; case M_EXCEPTION: case M_STRUCTURE: length = c_arraySize(c_structure(type)->references); for (i=0;i<length;i++) { member = c_member(c_structure(type)->references[i]); refType = c_specifier(member)->type; _cloneReference(refType, C_DISPLACE(data, member->offset), C_DISPLACE(dest, member->offset)); } break; case M_UNION: #define _CASE_(k,t) case k: v = t##Value(*((t *)data)); break switch (c_metaValueKind(c_metaObject(c_union(type)->switchType))) { _CASE_(V_BOOLEAN, c_bool); _CASE_(V_OCTET, c_octet); _CASE_(V_SHORT, c_short); _CASE_(V_LONG, c_long); _CASE_(V_LONGLONG, c_longlong); _CASE_(V_USHORT, c_ushort); _CASE_(V_ULONG, c_ulong); _CASE_(V_ULONGLONG, c_ulonglong); _CASE_(V_CHAR, c_char); _CASE_(V_WCHAR, c_wchar); default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal union switch type detected"); assert(FALSE); return FALSE; break; } #undef _CASE_ references = c_union(type)->references; if (references != NULL) { i=0; refType=NULL; nrOfRefs = c_arraySize(references); while ((i<nrOfRefs) && (refType == NULL)) { labels = c_unionCase(references[i])->labels; j=0; nrOfLabs = c_arraySize(labels); while ((j<nrOfLabs) && (refType == NULL)) { if (c_valueCompare(v,c_literal(labels[j])->value) == C_EQ) { c__cloneReferences(c_type(references[i]), C_DISPLACE(data, c_type(type)->alignment), C_DISPLACE(dest, c_type(type)->alignment)); refType = c_specifier(references[i])->type; } j++; } i++; } } break; case M_COLLECTION: refType = c_typeActualType(c_collectionType(type)->subType); switch (c_collectionType(type)->kind) { case C_ARRAY: ar = c_array(data); destar = c_array(dest); length = c_collectionType(type)->maxSize; if (length == 0) { length = c_arraySize(ar); } if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, ar[i], &destar[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(data, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; case C_SEQUENCE: seq = c_sequence(data); destseq = c_sequence(dest); length = c_sequenceSize(seq); if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, seq[i], &destseq[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(seq, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal collectionType found"); break; } break; case M_BASE: break; case M_TYPEDEF: c__cloneReferences(c_type(c_typeDef(type)->alias), data, dest); break; case M_ATTRIBUTE: case M_RELATION: refType = c_typeActualType(c_property(type)->type); _cloneReference(refType, C_DISPLACE(data, c_property(type)->offset), C_DISPLACE(dest, c_property(type)->offset)); break; case M_MEMBER: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, C_DISPLACE(data, c_member(type)->offset), C_DISPLACE(dest, c_member(type)->offset)); break; case M_UNIONCASE: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, data, dest); break; case M_MODULE: /* Do nothing */ break; case M_PRIMITIVE: /* Do nothing */ break; case M_EXTENT: case M_EXTENTSYNC: default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal meta object specified"); assert(FALSE); return FALSE; } return TRUE; }
struct v_messageExtCdrInfo * v_messageExtCdrInfoNew( c_type topicMessageType, const struct sd_cdrControl *control) { static const char headerTypeName[] = "kernelModule::v_messageExt"; c_base base = c_getBase (topicMessageType); c_property userDataProperty = c_property(c_metaResolve(c_metaObject(topicMessageType),"userData")); c_type topicDataType = userDataProperty->type; c_type headerClass = c_resolve (base, headerTypeName); c_type dataClass; c_type type; c_object o; c_array members; struct v_messageExtCdrInfo *xci; struct c_type_s const *tstk[2]; c_free(userDataProperty); /* Wrap user data in a class, so that we can make a struct with a pointer to it */ dataClass = c_type(c_metaDefine(c_metaObject(base), M_CLASS)); c_class(dataClass)->extends = NULL; o = c_metaDeclare(c_metaObject(dataClass), "userData", M_ATTRIBUTE); c_property(o)->type = c_keep(topicDataType); c_metaObject(dataClass)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(dataClass)); c_free(o); /* Make a struct containing two pointers, one to the v_messageExt class, and one to the just-created anonymous dataClass type, corresponding to struct v_messageExtCdrTmp */ type = c_type(c_metaDefine(c_metaObject(base),M_STRUCTURE)); members = c_arrayNew(c_member_t(base),2); members[0] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER); c_specifier(members[0])->name = c_stringNew(base,"h"); c_specifier(members[0])->type = c_keep(headerClass); members[1] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER); c_specifier(members[1])->name = c_stringNew(base,"d"); c_specifier(members[1])->type = c_keep(dataClass); c_structure(type)->members = members; c_metaObject(type)->definedIn = c_keep(base); c_metaFinalize(c_metaObject(type)); c_free(dataClass); c_free(headerClass); xci = os_malloc(sizeof(*xci)); xci->ci = sd_cdrInfoNewControl(type, control); /* Note: current simplistic annotation processing requires the annotations to be made in the order in which they are encountered when walking the type */ tstk[0] = type; tstk[1] = headerClass; if (sd_cdrNoteQuietRef(xci->ci, 2, tstk) < 0) { goto err_note; } tstk[1] = dataClass; if (sd_cdrNoteQuietRef(xci->ci, 2, tstk) < 0) { goto err_note; } if (sd_cdrCompile(xci->ci) < 0) { goto err_compile; } xci->vmsgType = c_keep(topicMessageType); c_free(type); return xci; err_compile: err_note: os_free(xci); c_free(type); return NULL; }