os_boolean
idl_stacDefCanStacBeAppliedToMember(
c_type memberType)
{
os_boolean stacCanBeApplied = OS_FALSE;
c_type dereffedType;
dereffedType = c_typeActualType(c_type(idl_stacDefResolveTypeDef(c_baseObject(memberType))));
if(c_baseObject(dereffedType)->kind == M_COLLECTION)
{
/* Can be a string or an array or a sequence */
if((c_collectionType(dereffedType)->kind == C_STRING))
{
if((c_collectionType(dereffedType)->maxSize != 0))
{
/* The string is bounded, stac can be applied */
stacCanBeApplied = OS_TRUE;
}
}
else if((c_collectionType(dereffedType)->kind == C_ARRAY))
{
/* bounded string embedded within arrays are allowed, recurse deeper */
stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_collectionType(dereffedType)->subType);
}
else if((c_collectionType(dereffedType)->kind == C_SEQUENCE))
{
/* bounded string embedded within sequences are allowed, recurse deeper */
stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_collectionType(dereffedType)->subType);
} /* else let memberIsStacOk remain false */
}
return stacCanBeApplied;
}
/* 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;
}