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);
}
}
c_structure
idl_stacDefFindMetaStructureResolved(
c_metaObject scope,
const char *typeName)
{
c_baseObject object;
c_structure structure;
object = c_baseObject(c_metaResolve(scope, typeName));
if(!object)
{
printf("FATAL ERROR | #pragma stac: Trying to locate structure '%s' in "
"scope '%s'. But no such object exists.\n",
typeName, c_metaScopedName(c_metaObject(scope)));
exit(-2);
}
/* Resolve typedefs */
idl_stacDefResolveTypeDef(object);
/* The final object (after typedef resolving) should be a structure */
if(object->kind != M_STRUCTURE)
{
printf("FATAL ERROR | #pragma stac: Trying to locate structure '%s' in "
"scope '%s'. But the identified object is not a structure.\n",
typeName, c_metaScopedName(c_metaObject(scope)));
exit(-2);
}
structure = c_structure(object);
return structure;
}
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 void
extractReferences(
c_type type,
c_object o,
c_voidp data)
{
switch (c_baseObject(type)->kind) {
case M_STRUCTURE:
case M_EXCEPTION:
extractStructReferences(c_structure(type),o,data);
break;
case M_CLASS:
if (c_class(type)->extends != NULL) {
extractReferences(c_type(c_class(type)->extends),o,data);
}
case M_INTERFACE:
extractInterfaceReferences(c_interface(type),o,data);
break;
case M_UNION:
break;
default:
break;
}
}
/*
* 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
v_indexInit(
v_index index,
c_type instanceType,
c_array keyList,
v_reader reader)
{
c_property keyProperty;
c_structure keyStructure;
c_char fieldName[16];
c_char *keyExpr;
c_size i,nrOfKeys,totalSize;
assert(index != NULL);
assert(C_TYPECHECK(index,v_index));
assert(C_TYPECHECK(instanceType,c_type));
keyProperty = c_property(c_metaResolve(c_metaObject(instanceType),"key"));
if (keyProperty) {
keyStructure = c_structure(keyProperty->type);
nrOfKeys = c_arraySize(keyStructure->members);
c_free(keyProperty);
} else {
nrOfKeys = 0;
}
if (nrOfKeys>0) {
totalSize = nrOfKeys * strlen("key.field0,");
if (nrOfKeys > 9) {
/* For each key number greater than one digit
* i.e. number of keys > 9 add one additional
* character space to the total size.
*/
totalSize += (nrOfKeys-9);
if (nrOfKeys > 99) {
/* For each key number greater than two digits
* i.e. number of keys > 99 add one additional
* character space to the total size.
*/
totalSize += (nrOfKeys-99);
}
}
keyExpr = (char *)os_alloca(totalSize);
keyExpr[0] = 0;
for (i=0;i<nrOfKeys;i++) {
os_sprintf(fieldName,"key.field%d",i);
os_strcat(keyExpr,fieldName);
if (i<(nrOfKeys-1)) { os_strcat(keyExpr,","); }
}
} else {
keyExpr = NULL;
}
index->reader = reader;
index->sourceKeyList = createKeyList(instanceType, keyList);
index->messageKeyList = c_keep(keyList); /* keyList is either topic->messageKeyList or a user-defined keylist */
index->objects = c_tableNew(instanceType,keyExpr);
index->notEmptyList = c_tableNew(instanceType,keyExpr);
if(keyExpr){
os_freea(keyExpr);
}
index->objectType = c_keep(instanceType);
}
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;
}
