os_boolean in_messageDeserializerReadPropertyAction( c_object object, c_voidp arg) { in_messageDeserializerPropertyActionArg* a = (in_messageDeserializerPropertyActionArg*)arg; c_property property; c_type type; c_voidp data; assert(object); assert(arg); assert(a->object); assert(a->transformer); assert(in_messageDeserializerIsValid(a->transformer)); /* For now, we are interested in properties only */ if (c_baseObjectKind(object) == M_ATTRIBUTE) { property = c_property(object); type = c_typeActualType(property->type); data = C_DISPLACE(a->object, (c_address)property->offset); in_messageDeserializerReadType(a->transformer, type, data); } return OS_TRUE; }
void in_messageDeserializerReadStructure( in_messageDeserializer _this, c_type type, c_voidp data) { c_structure structure = c_structure(type); c_member member; c_type memberType; os_uint32 size; os_uint32 i; c_voidp o; assert(_this); assert(in_messageDeserializerIsValid(_this)); assert(type); assert(data); size = c_arraySize(structure->members); for (i = 0; i < size; i++) { member = structure->members[i]; assert(member); o = C_DISPLACE(data, (c_address)member->offset); memberType = c_typeActualType(c_specifierType(member)); in_messageDeserializerReadType(_this, memberType, o); } }
os_boolean idl_stacDefCanStacBeAppliedToMember( c_type memberType) { os_boolean stacCanBeApplied = OS_FALSE; c_type dereffedType; dereffedType = c_typeActualType(c_type(idl_stacDefResolveTypeDef(c_baseObject(memberType)))); if(c_baseObject(dereffedType)->kind == M_COLLECTION) { /* Can be a string or an array or a sequence */ if(c_collectionType(dereffedType)->kind == OSPL_C_STRING) { if((c_collectionType(dereffedType)->maxSize != 0)) { /* The string is bounded, stac can be applied */ stacCanBeApplied = OS_TRUE; } } else if(c_collectionType(dereffedType)->kind == OSPL_C_ARRAY) { /* bounded string embedded within arrays are allowed, recurse deeper */ stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_collectionType(dereffedType)->subType); } /* else let memberIsStacOk remain false */ } return stacCanBeApplied; }
/* * 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_unionCase sd_unionDetermineActiveCase( c_union v_union, c_object object) { c_value switchValue; c_type switchType; switchType = c_typeActualType(v_union->switchType); /* Determine value of the switch field */ switchValue = sd_unionDetermineSwitchValue(switchType, object); /* Determine the label corresponding to this field */ return sd_unionDetermineLabel(v_union, switchValue); }
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; } } }
static void copyInterfaceReferences( c_interface m, c_voidp dest, c_voidp data) { c_long i,length; c_property property; c_type type; c_object *ref; if (m->references == NULL) { return; } length = c_arraySize(m->references); for (i=0;i<length;i++) { property = c_property(m->references[i]); type = c_typeActualType(property->type); switch (c_baseObject(type)->kind) { case M_CLASS: case M_INTERFACE: case M_COLLECTION: case M_BASE: ref = C_DISPLACE(dest,property->offset); c_copyIn(type,C_REFGET(data,property->offset),ref); break; case M_EXCEPTION: case M_STRUCTURE: case M_UNION: copyReferences(type,C_DISPLACE(dest,property->offset), C_DISPLACE(data,property->offset)); break; default: assert(FALSE); break; } } }
static c_bool c_deepwalkProperty( c_metaObject object, c_metaWalkActionArg actionArg) { c_interfaceContext context = (c_interfaceContext)actionArg; c_property property; c_type propertyType; c_object propertyData; /* For now, we are interested in properties only */ if (c_baseObject(object)->kind == M_ATTRIBUTE) { property = c_property(object); propertyType = c_typeActualType(property->type); /* For now, skip attributes which are class-references */ propertyData = C_DISPLACE(*context->objectPtr, (c_address)property->offset); c_deepwalkType(propertyType, &propertyData, context->action, context->actionArg); } return TRUE; }
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); } }
void in_messageDeserializerReadUnion( in_messageDeserializer _this, c_type type, c_voidp data) { c_union utype = c_union(type); c_type caseType; c_type switchType; c_unionCase deflt; c_unionCase activeCase; c_unionCase currentCase; c_value switchValue; c_literal label; c_voidp o; os_uint32 length; os_uint32 i; os_uint32 j; os_uint32 n; assert(_this); assert(type); assert(data); /* action for the switch */ switchType = c_typeActualType(utype->switchType); in_messageDeserializerReadType(_this, switchType, data); /* Determine value of the switch field */ switch (c_baseObjectKind(switchType)) { case M_PRIMITIVE: switch (c_primitiveKind(switchType)) { #define __CASE__(prim, type) \ case prim: switchValue = type##Value(*((type *)data)); 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 *)data); break; default: switchValue = c_undefinedValue(); assert(FALSE); break; } /* Determine the label corresponding to this field */ activeCase = NULL; deflt = NULL; length = c_arraySize(utype->cases); for (i = 0; (i < length) && !activeCase; i++) { currentCase = c_unionCase(utype->cases[i]); n = c_arraySize(currentCase->labels); if (n > 0) { for (j = 0; (j < n) && !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) { if (c_type(utype)->alignment >= utype->switchType->size) { length = c_type(utype)->alignment; } else { length = utype->switchType->size; } o = C_DISPLACE(data, (c_address)length); caseType = c_typeActualType(c_specifierType(activeCase)); in_messageDeserializerReadType(_this, caseType, o); } }
c_type idl_stacDefConvertStacApprovedMember( c_structure structure, c_type orgMemberType) { c_type dereffedOrgType; c_metaObject o = NULL; c_type newType; os_char buffer[1024]; c_metaObject found; memset(buffer, 0, 1024); dereffedOrgType = c_typeActualType(c_type(idl_stacDefResolveTypeDef(c_baseObject(orgMemberType)))); if(c_baseObject(dereffedOrgType)->kind == M_COLLECTION) { o = c_metaObject(c_metaDefine(c_metaObject(structure), M_COLLECTION)); /* Can be a string or an array or a sequence */ if(c_collectionType(dereffedOrgType)->kind == OSPL_C_STRING) { if((c_collectionType(dereffedOrgType)->maxSize != 0)) { c_collectionType(o)->kind = OSPL_C_ARRAY; c_collectionType(o)->subType = c_type(c_metaResolve(c_metaObject(structure), "c_char")); /* increase maxSize with 1 to accomodate the '\0' char found in strings */ c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize + 1; os_sprintf( buffer, "C_ARRAY<%s,%d>", c_metaObject(c_collectionType(o)->subType)->name, c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/); } else { printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but " "encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) " "has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n", c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } } else if(c_collectionType(dereffedOrgType)->kind == OSPL_C_ARRAY) { c_collectionType(o)->kind = OSPL_C_ARRAY; /* increase maxSize with 1 to accomodate the '\0' char found in strings */ c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize; c_collectionType(o)->subType = idl_stacDefConvertStacApprovedMember(structure, c_collectionType(dereffedOrgType)->subType); os_sprintf( buffer, "C_ARRAY<%s,%d>", c_metaObject(c_collectionType(o)->subType)->name, c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/); } else if(c_collectionType(dereffedOrgType)->kind == OSPL_C_SEQUENCE) { c_collectionType(o)->kind = OSPL_C_SEQUENCE; /* increase maxSize with 1 to accomodate the '\0' char found in strings */ c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize; c_collectionType(o)->subType = idl_stacDefConvertStacApprovedMember(structure, c_collectionType(dereffedOrgType)->subType); os_sprintf( buffer, "C_SEQUENCE<%s,%d>", c_metaObject(c_collectionType(o)->subType)->name, c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/); } else { printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but " "encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) " "has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n", c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } } else { printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but " "encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) " "has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n", c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } if(o) { c_metaObject(o)->definedIn = c_metaObject(structure); c_metaFinalize(o); found = c_metaBind(c_metaObject(structure), &buffer[0], o); c_free(o); newType = c_type(found); } else { printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but " "encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) " "has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n", c_metaScopedName(c_metaObject(structure))); assert(0); exit(-2); } return newType; }
/* * 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; }
void c_copyOut ( c_type type, c_object o, c_voidp *data) { c_long i,size; c_type t,subType; if (data == NULL) { OS_REPORT(OS_ERROR,"Database misc",0, "c_copyOut: no destination specified"); return; } if (o == NULL) { *data = NULL; return; } t = c_typeActualType(type); size = c_typeSize(t); if (size == 0) { OS_REPORT(OS_WARNING,"Database misc",0, "c_copyOut: zero sized type specified"); *data = NULL; return; } if (*data == NULL) { *data = (c_voidp)os_malloc(size); } if (c_baseObject(t)->kind == M_COLLECTION) { switch(c_collectionType(t)->kind) { case C_STRING: *data = os_strdup((c_char *)o); break; case C_LIST: case C_BAG: case C_SET: case C_MAP: case C_DICTIONARY: OS_REPORT(OS_WARNING,"Database misc",0, "c_copyOut: ODL collections unsupported"); assert(FALSE); break; case C_ARRAY: size = c_collectionType(t)->maxSize; if (size > 0) { subType = c_collectionType(t)->subType; for (i=0;i<size;i++) { c_copyIn(subType, ((c_voidp *)o)[i], &((c_voidp *)(*data))[i]); } } else { OS_REPORT(OS_WARNING,"Database misc",0, "c_copyOut: dynamic sized arrays unsupported"); } case C_SEQUENCE: OS_REPORT(OS_WARNING,"Database misc",0, "c_copyOut: sequences unsupported"); assert(FALSE); break; default: OS_REPORT_1(OS_ERROR,"Database misc",0, "c_copyOut: unknown collection kind (%d)", c_collectionType(t)->kind); assert(FALSE); break; } } else if (c_typeIsRef(t)) { memcpy(*data,*(void**)o,size); extractReferences(t,*(void**)o,*data); } else { memcpy(*data,o,size); extractReferences(t,o,*data); } }
void c_cloneIn ( c_type type, c_voidp data, c_voidp *dest) { c_long size,subSize; c_type t; if (data == NULL) { *dest = NULL; return; } t = c_typeActualType(type); if (c_baseObject(t)->kind == M_COLLECTION) { switch(c_collectionType(t)->kind) { case C_STRING: *dest = c_stringNew(c_getBase(t), data); break; case C_LIST: case C_BAG: case C_SET: case C_MAP: case C_DICTIONARY: OS_REPORT(OS_WARNING,"Database misc",0, "c_cloneIn: ODL collections unsupported"); break; case C_ARRAY: subSize = c_collectionType(t)->subType->size; size = c_collectionType(t)->maxSize; if (size == 0) { size = c_arraySize(data); *dest = c_newArray(c_collectionType(t), size); } if (size > 0) { memcpy(*dest, data, size * subSize); /* Find indirections */ c__cloneReferences(t, data, dest); } break; case C_SEQUENCE: subSize = c_collectionType(t)->subType->size; size = c_sequenceSize(data); if (size > 0) { *dest = c_newSequence(c_collectionType(t), size); memcpy(*dest, data, size * subSize); /* Find indirections */ c__cloneReferences(t, data, dest); } break; break; default: OS_REPORT_1(OS_ERROR,"Database misc",0, "c_cloneIn: unknown collection kind (%d)", c_collectionType(t)->kind); assert(FALSE); break; } } else if (c_typeIsRef(t)) { *dest = c_new(t); memcpy(*dest, data, t->size); /* Find indirections */ c__cloneReferences(t, data, *dest); } else { memcpy(*dest, data, t->size); /* Find indirections */ c__cloneReferences(t, data, *dest); } }
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; }
void c_copyIn ( c_type type, c_voidp data, c_voidp *dest) { c_long size, subSize, i; c_type t, refType; if (data == NULL) { *dest = NULL; return; } t = c_typeActualType(type); if (c_baseObject(t)->kind == M_COLLECTION) { switch(c_collectionType(t)->kind) { case C_STRING: *dest = c_stringNew(c_getBase(t),data); return; case C_LIST: case C_BAG: case C_SET: case C_MAP: case C_DICTIONARY: OS_REPORT(OS_WARNING,"Database misc",0, "c_copyIn: ODL collections unsupported"); break; case C_ARRAY: refType = c_typeActualType(c_collectionType(type)->subType); subSize = refType->size; size = c_collectionType(t)->maxSize; if (size == 0) { size = c_arraySize(data); *dest = c_newArray(c_collectionType(t), size); } if (size > 0) { c_array ar = c_array(data); c_array destar = c_array(*dest); if (c_typeIsRef(refType)) { for (i = 0; i < size; i++) { copyReferences(refType, destar[i], ar[i]); } } else { memcpy(*dest, data, size * subSize); /* Find indirections */ for (i = 0; i < size; i++) { copyReferences(refType, C_DISPLACE(destar, (i*subSize)), C_DISPLACE(ar, (i*subSize))); } } } break; case C_SEQUENCE: refType = c_typeActualType(c_collectionType(type)->subType); subSize = refType->size; size = c_sequenceSize(data); if (size > 0) { *dest = c_newSequence(c_collectionType(t), size); if (c_typeIsRef(refType)) { c_sequence seq = c_sequence(data); c_sequence destseq = c_sequence(*dest); for (i = 0; i < size; i++) { copyReferences(refType, destseq[i], seq[i]); } } else { memcpy(*dest, data, size * subSize); /* Find indirections */ for (i = 0; i < size; i++) { copyReferences(refType, C_DISPLACE(*dest, (i*subSize)), C_DISPLACE(data, (i*subSize))); } } } break; default: OS_REPORT_1(OS_ERROR,"Database misc",0, "c_copyIn: unknown collection kind (%d)", c_collectionType(t)->kind); assert(FALSE); break; } } else if (c_typeIsRef(t)) { *dest = c_new(t); memcpy(*dest, data, t->size); copyReferences(t, *dest, data); } else { memcpy(*dest, data, t->size); copyReferences(t, *dest, data); } }