c_object c_checkType ( c_object o, const c_char *name) { c_type type; c_string str; c_bool found = FALSE; c_bool stop = FALSE; if (o == NULL) { return NULL; } c_assertValidDatabaseObject(o); assert(c_refCount(o) > 0); assert(name != NULL); type = c__getType(o); while (!found && !stop) { str = c_metaObject(type)->name; if (str == NULL) { found = TRUE; /** assume TRUE **/ } else if (strcmp(str,name) != 0) { switch (c_baseObject(type)->kind) { case M_CLASS: type = c_type(c_class(type)->extends); if (type == NULL) { if ((strcmp(str,"c_base") == 0) && (strcmp(name,"c_module") == 0)) { found = TRUE; } stop = TRUE; } break; case M_TYPEDEF: type = c_typeDef(type)->alias; if (type == NULL) { stop = TRUE; } break; default: stop = TRUE; } } else { found = TRUE; } } if (!found) { #ifndef NDEBUG if(o != NULL){ str = c_metaObject(c__getType(o))->name; OS_REPORT_2(OS_ERROR, "Database", 0, "Type mismatch: object type is %s but %s was expected\n", str,name); } #endif return NULL; } return o; }
c_baseObject idl_stacDefResolveTypeDef( c_baseObject obj) { c_baseObject object; object = obj; while(object->kind == M_TYPEDEF) { object = c_baseObject(c_typeDef(object)->alias); } return object; }
static c_bool _cloneReference ( c_type type, c_voidp data, c_voidp dest) { c_type t = type; assert(data); assert(type); while (c_baseObject(t)->kind == M_TYPEDEF) { t = c_typeDef(t)->alias; } switch (c_baseObject(t)->kind) { case M_CLASS: case M_INTERFACE: c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest); break; case M_BASE: case M_COLLECTION: if ((c_collectionType(t)->kind == C_ARRAY) && (c_collectionType(t)->maxSize != 0)) { c__cloneReferences(t, data, dest); } else { c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest); } break; case M_EXCEPTION: case M_STRUCTURE: case M_UNION: c__cloneReferences(t, data, dest); break; case M_EXTENT: case M_EXTENTSYNC: c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest); break; default: OS_REPORT(OS_ERROR, "cloneReference",0, "illegal object detected"); assert(FALSE); return FALSE; } return TRUE; }
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; } } }
c_iter c_bindTypes( c_metaObject scope, c_iter declarations, c_type type) { c_iter typeDefs; c_declarator d; c_metaObject o; typeDefs = NULL; d = (c_declarator)c_iterTakeFirst(declarations); while (d != NULL) { o = c_metaDeclare(scope,d->name,M_TYPEDEF); c_typeDef(o)->alias = c_declaratorType(d,type); c_metaFinalize(o); typeDefs = c_iterInsert(typeDefs,o); os_free(d); d = (c_declarator)c_iterTakeFirst(declarations); } c_iterFree(declarations); return typeDefs; }
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; }