char *
idl_genXMLmeta (
c_type type)
{
sd_serializer metaSer;
sd_serializedData serData;
char *metaDescription = NULL;
c_iter replaceInfo;
c_iter replaceInfoStac;
replaceInfo = idl_catsDefConvertAll(idl_catsDefDefGet());
replaceInfoStac = idl_stacDefConvertAll(idl_stacDefDefGet());
metaSer = sd_serializerXMLTypeinfoNew (c_getBase(c_object(type)), TRUE);
if (metaSer)
{
serData = sd_serializerSerialize (metaSer, c_object(type));
if (serData)
{
metaDescription = sd_serializerToString (metaSer, serData);
}
sd_serializerFree (metaSer);
}
idl_catsDefRestoreAll(idl_catsDefDefGet(), replaceInfo);
idl_stacDefRestoreAll(idl_stacDefDefGet(), replaceInfoStac);
return metaDescription;
}
os_boolean
idl_stacDef_isStacDefined(
idl_scope scope,
const char *name,
idl_typeSpec typeSpec,
idl_typeSpec* baseStringTypeDereffered)
{
os_boolean isStacDefined = OS_FALSE;
idl_typeSpec typeDereffered;
idl_typeSpec subType;
idl_scope tmpScope;
os_char* containingElement;
idl_basicType basic;
c_ulong maxlen;
/* resolve any type defs */
typeDereffered = idl_typeDefResolveFully(typeSpec);
if(idl_typeSpecType(typeDereffered) == idl_tarray)
{
/* If this is an array, then get the sub type and recurse deeper into this
* operation. Arrays of bounded strings are allowed for pragma stac
*/
subType = idl_typeArrayActual(idl_typeArray(typeDereffered));
isStacDefined = idl_stacDef_isStacDefined(scope, name, subType, baseStringTypeDereffered);
} else if(idl_typeSpecType(typeDereffered) == idl_tbasic)
{
/* Get the basic type to see if it is a string */
basic = idl_typeBasicType(idl_typeBasic(typeDereffered));
if(basic == idl_string)
{
/* If this is indeed a string, then get the 'maxLen' attribute of the
* string type. If it is not 0, then this is a bounded string
*/
maxlen = idl_typeBasicMaxlen(idl_typeBasic(typeDereffered));
if(maxlen != 0)
{
tmpScope = idl_scopeDup(scope);
containingElement = idl_scopeElementName(idl_scopeCur (scope));
idl_scopePop(tmpScope);
isStacDefined = idl_stacListItemIsDefined (idl_stacDefDefGet(), tmpScope, containingElement, name);
if(isStacDefined && baseStringTypeDereffered)
{
*baseStringTypeDereffered = typeDereffered;
}
} /* else stac define status not relevant for this member */
} /* else stac define status not relevant for this member */
} /* else stac define status not relevant for this member */
return isStacDefined;
}
/* Check if there is a stac applied to the given key. */
c_bool
idl_isStacDefFor(
c_metaObject scope,
c_char *typeName,
c_char *key)
{
idl_stacDef stacDef = idl_stacDefDefGet();
idl_stacMap stacMap;
c_ulong stacMapIdx;
c_iter stacList;
os_uint32 stacListSize;
os_uint32 stacIdx;
os_boolean stacDefFor = OS_FALSE;
if (stacDef != NULL) {
/* check all stac definition list elements */
for (stacMapIdx = 0; stacMapIdx < c_iterLength(stacDef->stacList) && !stacDefFor; stacMapIdx++) {
stacMap = c_iterObject(stacDef->stacList, stacMapIdx);
if (c_metaCompare(scope, stacMap->scope) == E_EQUAL &&
strcmp(typeName, stacMap->typeName) == 0)
{
/* for each stac in stacList, check if it's equal to key */
stacList = c_splitString(stacMap->stacList, ",");
stacListSize = c_iterLength(stacList);
if (stacListSize == 0) {
stacDefFor = OS_TRUE;
}
else if(idl_stacDefOnlyExclusionsDefined(stacMap->stacList))
{
if(!idl_stacDefIsFieldExcluded(stacMap->stacList, key))
{
stacDefFor = OS_TRUE;
}
} else
{
for(stacIdx = 0; stacIdx < stacListSize; stacIdx++)
{
if (strcmp(c_iterTakeFirst(stacList), key) == 0) {
stacDefFor = OS_TRUE;
}
}
}
}
}
}
return stacDefFor;
}
