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