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