c_type
c_declaratorType(
c_declarator declaration,
c_type type)
{
c_literal l;
c_metaObject scope;
c_collectionType o;
if (declaration->sizes != NULL) {
scope = c_metaObject(c__getBase(type));
l = c_iterTakeFirst(declaration->sizes);
while (l != NULL) {
o = (c_collectionType)c_metaDefine(scope,M_COLLECTION);
o->kind = OSPL_C_ARRAY;
if (l->value.kind == V_LONGLONG) {
assert (l->value.is.LongLong >= 0);
o->maxSize = (c_ulong) l->value.is.LongLong;
} else {
assert (l->value.is.Long >= 0);
o->maxSize = (c_ulong) l->value.is.Long;
}
o->subType = type;
c_metaFinalize(c_metaObject(o));
type = (c_type)o;
c_free(l);
l = c_iterTakeFirst(declaration->sizes);
}
}
return type;
}
c_array
c_metaArray(
c_metaObject scope,
c_iter iter,
c_metaKind kind)
{
c_long i;
struct copyToArrayArg arg;
c_type type;
if (kind) {
/* suppress warnings */
}
i = c_iterLength(iter);
if (i == 0) {
arg.a = NULL;
} else {
type = c_object_t(c__getBase(scope));
arg.a = c_arrayNew(type,i);
arg.index = 0;
c_iterWalk(iter,copyToArray,&arg);
c_iterFree(iter);
c_free(type);
}
return arg.a;
}
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;
}
c_field
c_fieldConcat (
c_field head,
c_field tail)
{
c_base base;
c_long i, len1, len2, totlen;
c_field field;
base = c__getBase(head);
len1 = c_arraySize(head->path);
len2 = c_arraySize(tail->path);
field = c_new(c_field_t(base));
if (field) {
field->type = c_keep(tail->type);
field->kind = tail->kind;
field->path = c_newArray(c_fieldPath_t(base),len1 + len2);
for (i=0;i<len1;i++) {
field->path[i] = c_keep(head->path[i]);
}
for (i=0;i<len2;i++) {
field->path[i+len1] = c_keep(tail->path[i]);
}
len1 = c_arraySize(head->refs);
len2 = c_arraySize(tail->refs);
totlen = len1 + len2;
if (totlen > 0) {
field->offset = 0;
field->refs = c_newArray(c_fieldRefs_t(base),totlen);
if (len1) {
for (i=0;i<len1;i++) {
field->refs[i] = head->refs[i];
}
} else {
tail->refs[0] = (c_voidp)head->offset;
len1 = 1;
}
for (i=0;i<len2;i++) {
field->refs[i+len1] = tail->refs[i];
}
} else {
field->offset = head->offset + tail->offset;
field->refs = NULL;
}
len1 = strlen(head->name);
len2 = strlen(tail->name);
field->name = c_stringMalloc(base,len1+len2+2);
os_sprintf(field->name,"%s.%s",head->name,tail->name);
} else {
OS_REPORT(OS_ERROR,
"database::c_fieldConcat",0,
"Failed to allocate c_field object.");
}
return field;
}
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;
}
