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