static char * idl_unionCaseTypeFromTypeSpec( idl_typeSpec typeSpec) { char typeName[512]; if (idl_typeSpecType(typeSpec) == idl_tbasic) { snprintf(typeName, sizeof(typeName), "%s", idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else if (idl_typeSpecType(typeSpec) == idl_tseq) { snprintf (typeName, sizeof(typeName), "%s%s", idl_corbaJavaTypeFromTypeSpec(idl_typeSeqActual(idl_typeSeq(typeSpec))), idl_sequenceIndexString (idl_typeSeq(typeSpec))); } else if (idl_typeSpecType(typeSpec) == idl_tarray) { snprintf(typeName, sizeof(typeName), "%s%s", idl_corbaJavaTypeFromTypeSpec(idl_typeArrayActual(idl_typeArray(typeSpec))), idl_arrayJavaIndexString(idl_typeArray(typeSpec))); } else if (idl_typeSpecType(typeSpec) == idl_ttypedef) { return idl_unionCaseTypeFromTypeSpec(idl_typeDefActual(idl_typeDef(typeSpec))); } else { if ((idl_typeSpecType(typeSpec) == idl_tstruct) || (idl_typeSpecType (typeSpec) == idl_tunion) || (idl_typeSpecType (typeSpec) == idl_tenum)) { snprintf(typeName, sizeof(typeName), "%s", idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else { printf ("idl_unionCaseTypeFromTypeSpec: Unexpected type %d\n", idl_typeSpecType(typeSpec)); } } return os_strdup(typeName); }
/* @brief generate dimension of an array slice * * arraySliceDimensions is a local support function to generate * the array dimensions of an array slice * * @param typeArray Specifies the type of the array */ static void idl_arraySliceDimensions( idl_typeArray typeArray) { idl_fileOutPrintf(idl_fileCur(), "[%d]", idl_typeArraySize(typeArray)); if (idl_typeSpecType(idl_typeArrayType(typeArray)) == idl_tarray && idl_typeSpecType(idl_typeArrayType(idl_typeArray(idl_typeArrayType(typeArray)))) == idl_tarray) { idl_arraySliceDimensions(idl_typeArray(idl_typeArrayType(typeArray))); } }
/** @brief callback function called on definition of a union case in the IDL input file. * * Generate code for the following IDL construct: * @verbatim union <union-name> switch(<switch-type>) { case label1.1; .. case label1.n; => <union-case-1>; case label2.1; .. case label2.n; => ... ... case labeln.1; .. case labeln.n; => <union-case-n>; default: => <union-case-m>; }; @endverbatim * * If the type specification is idl_tbasic a standard mapping can be generated: * @verbatim string <name>; => c_string <name>; string <name,length>; => c_string <name>; char <name>; => c_char <name>; octet <name>; => c_octet <name>; short <name>; => c_short <name>; unsigned short <name>; => c_ushort <name>; long <name>; => c_long <name>; unsigned long <name>; => c_ulong <name>; long long <name>; => c_longlong <name>; unsigned long long <name>; => c_ulonglong <name>; float <name>; => c_float <name>; double <name>; => c_double <name>; boolean <name>; => c_bool <name>; @endverbatim * If the type specification is a user defined idl_ttypedef, idl_tenum, * idl_tstruct or idl_tunion a scoped name mapping will be generated. * @verbatim <typedef-name> <name>; => enum <scope-elements>_<typedef-name> <name>; <enum-name> <name>; => enum <scope-elements>_<enum-name> <name>; <struct-name> <name>; => struct <scope-elements>_<structure-name> <name>; <union-name> <name>; => struct <scope-elements>_<union-name> <name>; @endverbatim * If the type specification is idl_tarray then generate a scoped name * with the array specifiers: * @verbatim <other-usertype-name> <name>[n1]..[nn]; => <scope-elements>_<other-usertype-name> <name>[n1]..[nn]; <basic-type> <name>[n1]..[nn]; => <basic-type-mapping> <name>[n1]..[nn]; sequence<spec> <name>[n1]..[nn]; => c_array <name>[n1]..[nn]; sequence<spec,length> <name>[n1]..[nn]; => c_array <name>[n1]..[nn]; @endverbatim * If the type specification is idl_tseq then generate a mapping on c_sequence: * @verbatim sequence<spec> <name>; => c_sequence <name>; sequence<spec,length> <name>; => c_sequence <name>; @endverbatim * * @param scope Current scope (the union the union case is defined in) * @param name Name of the union case * @param typeSpec Specifies the type of the union case */ static void idl_unionCaseOpenClose( idl_scope scope, const char *name, idl_typeSpec typeSpec, void *userData) { if (idl_typeSpecType(typeSpec) == idl_ttypedef || idl_typeSpecType(typeSpec) == idl_tenum || idl_typeSpecType(typeSpec) == idl_tstruct || idl_typeSpecType(typeSpec) == idl_tunion || idl_typeSpecType(typeSpec) == idl_tbasic) { /* generate code for a standard mapping or a typedef, enum, struct or union user-type mapping */ idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "%s %s;\n", idl_scopedSplTypeIdent(typeSpec), idl_languageId(name)); } else if (idl_typeSpecType(typeSpec) == idl_tarray) { /* generate code for an array mapping */ idl_printIndent(indent_level); if (idl_typeSpecType(idl_typeArrayActual (idl_typeArray(typeSpec))) != idl_tseq) { idl_fileOutPrintf( idl_fileCur(), "%s %s", idl_scopedSplTypeIdent(idl_typeArrayActual (idl_typeArray(typeSpec))), idl_languageId (name)); } else { idl_fileOutPrintf( idl_fileCur(), "c_array %s", idl_languageId(name)); } idl_arrayDimensions(idl_typeArray(typeSpec), OS_FALSE); idl_fileOutPrintf(idl_fileCur(), ";\n"); } else if (idl_typeSpecType(typeSpec) == idl_tseq) { /* generate code for a sequence mapping */ idl_printIndent(indent_level); if (idl_typeSeqMaxSize (idl_typeSeq(typeSpec)) == 0) { /* unbounded sequence */ idl_fileOutPrintf(idl_fileCur(), "c_sequence %s", idl_languageId (name)); } else { /* bounded sequence */ idl_fileOutPrintf(idl_fileCur(), "c_sequence %s", idl_languageId (name)); } idl_fileOutPrintf(idl_fileCur(), ";\n"); } else { printf("idl_unionCaseOpenClose: Unsupported union case type (case name = %s, type = %s)\n", name, idl_scopedTypeName(typeSpec)); } }
static c_ulong idl_genArrayTotalDimension( idl_typeArray typeArray) { c_ulong result = 0; idl_typeSpec ptr; result = (c_ulong)idl_typeArraySize(typeArray); ptr = idl_typeArrayType(typeArray); while (idl_typeSpecType(ptr) == idl_tarray) { result = result * (c_ulong)idl_typeArraySize(idl_typeArray(ptr)); ptr = idl_typeArrayType(idl_typeArray(ptr)); } return result; }
/* @brief function to find out whether the elements of an array * require initialization. * * idl_arrayElementsNeedInitialization is a local support function to find out * whether the specified array is of a type for which all elements need to be * initialized individually. If the array is of a primitive type, this is never * necessary, but if the array contains a reference type and no underlying * sequences (which will be initialized to 0 elements) then for loops will * need to be created to explicitly initialize all of these attributes. * * @param typeSpec Specifies the attribute type that needs to be investigated. */ static int idl_arrayElementsNeedInitialization( idl_typeArray typeArray) { int initRequired = FALSE; /* Obtain the type of the array. */ idl_typeSpec typeSpec = idl_typeArrayType(typeArray); /* Resolve potential typedefs. */ while (idl_typeSpecType(typeSpec) == idl_ttypedef) { typeSpec = idl_typeDefRefered(idl_typeDef(typeSpec)); } if (idl_typeSpecType(typeSpec) == idl_tarray) { initRequired = idl_arrayElementsNeedInitialization(idl_typeArray(typeSpec)); } else if ( idl_typeSpecType(typeSpec) == idl_tstruct || idl_typeSpecType(typeSpec) == idl_tunion || idl_typeSpecType(typeSpec) == idl_tenum || ( idl_typeSpecType(typeSpec) == idl_tbasic && idl_typeBasicType(idl_typeBasic (typeSpec)) == idl_string) ) { initRequired = TRUE; } return initRequired; }
/** @brief callback function called on definition of a union case in the IDL input file. * * Generate code for the following IDL construct: * @verbatim union <union-name> switch(<switch-type>) { case label1.1; .. case label1.n; => <union-case-1>; case label2.1; .. case label2.n; => ... ... case labeln.1; .. case labeln.n; => <union-case-n>; default: => <union-case-m>; }; @endverbatim * * @param scope Current scope (the union the union case is defined in) * @param name Name of the union case * @param typeSpec Specifies the type of the union case */ static void idl_unionCaseOpenClose( idl_scope scope, const char *name, idl_typeSpec typeSpec, void *userData) { struct idl_genSACPPData *arg = (struct idl_genSACPPData *)userData; char *seqName; switch (idl_typeSpecType(typeSpec)) { case idl_tbasic: case idl_tenum: case idl_ttypedef: case idl_tstruct: case idl_tunion: break; case idl_tarray: /* generate code for an array mapping */ snprintf(arg->buffer,MAX_BUFFER,"_%s_array", name); seqName = os_strdup(arg->buffer); idl_arrayTypeImpl(idl_typeArray(typeSpec),seqName,arg); os_free(seqName); break; case idl_tseq: break; default: printf("idl_unionCaseOpenClose: Unsupported union member type (member name = %s, type name = %s)\n", name, idl_scopedTypeName(typeSpec)); } }
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; }
c_char * idl_arrayJavaIndexString ( idl_typeArray typeArray) { c_char *arrayString; os_size_t arrayStringLen; c_char *arrayStringPrev; if (idl_typeSpecType(idl_typeArrayType(typeArray)) == idl_tarray) { arrayStringPrev = idl_arrayJavaIndexString(idl_typeArray(idl_typeArrayType(typeArray))); arrayStringLen = strlen(arrayStringPrev) + 3; arrayString = os_malloc(arrayStringLen); snprintf(arrayString, arrayStringLen, "[]%s", arrayStringPrev); } else if (idl_typeSpecType(idl_typeArrayType(typeArray)) == idl_tseq) { arrayStringPrev = idl_sequenceIndexString(idl_typeSeq(idl_typeArrayType (typeArray))); arrayStringLen = strlen(arrayStringPrev) + 3; arrayString = os_malloc(arrayStringLen); snprintf(arrayString, arrayStringLen, "[]%s", arrayStringPrev); } else if (idl_typeSpecType(idl_typeArrayType(typeArray)) == idl_ttypedef && idl_typeSpecType(idl_typeDefActual(idl_typeDef(idl_typeArrayType(typeArray)))) == idl_tarray) { arrayStringPrev = idl_arrayJavaIndexString(idl_typeArray(idl_typeDefActual(idl_typeDef(idl_typeArrayType(typeArray))))); arrayStringLen = strlen(arrayStringPrev) + 3; arrayString = os_malloc(arrayStringLen); snprintf(arrayString, arrayStringLen, "[]%s", arrayStringPrev); } else if (idl_typeSpecType(idl_typeArrayType(typeArray)) == idl_ttypedef && idl_typeSpecType(idl_typeDefActual(idl_typeDef(idl_typeArrayType(typeArray)))) == idl_tseq) { arrayStringPrev = idl_sequenceIndexString(idl_typeSeq(idl_typeDefActual(idl_typeDef(idl_typeArrayType(typeArray))))); arrayStringLen = strlen(arrayStringPrev) + 3; arrayString = os_malloc(arrayStringLen); snprintf(arrayString, arrayStringLen, "[]%s", arrayStringPrev); } else { arrayString = os_malloc(3); snprintf(arrayString, 3, "[]"); } return arrayString; }
/* @brief generate dimension of an array or a sequence * * java_arrayDimensions is a local support function to generate * the dimensions of a java Array representing an IDL sequence or * array. Since Sequences will always be initialized to 0 elements, * its dimensions will always be assigned 0. Arrays will be assigned * their IDL dimensions. * * @param typeSeq Specifies the type of the sequence */ static void java_arrayDimensions( idl_typeSpec typeSpec) { while (idl_typeSpecType(typeSpec) == idl_ttypedef) { typeSpec = idl_typeDefRefered(idl_typeDef(typeSpec)); } if (idl_typeSpecType(typeSpec) == idl_tarray) { idl_typeArray typeArray = idl_typeArray(typeSpec); idl_fileOutPrintf (idl_fileCur(), "[%d]", idl_typeArraySize(typeArray)); java_arrayDimensions(idl_typeArrayType(typeArray)); } else if (idl_typeSpecType(typeSpec) == idl_tseq) { idl_fileOutPrintf(idl_fileCur(), "[0]"); java_arrayDimensions(idl_typeSeqType(idl_typeSeq(typeSpec))); } }
/* @brief generate dimension of an array * * arrayDimensions is a local support function to generate * the array dimensions of an array * * @param typeArray Specifies the type of the array */ static void idl_arrayDimensions ( idl_typeArray typeArray, os_boolean resolveTypedefs) { idl_typeSpec subType; idl_fileOutPrintf(idl_fileCur(), "[%d]", idl_typeArraySize(typeArray)); subType = idl_typeArrayType(typeArray); while(resolveTypedefs && idl_typeSpecType(subType) == idl_ttypedef) { subType = idl_typeDefResolveFully(subType); } if (idl_typeSpecType(subType) == idl_tarray) { idl_arrayDimensions (idl_typeArray(subType), resolveTypedefs); } }
/* @brief generate initialization of array elements. * * idl_ifArrayInitializeElements is a local support function to initialize * the elements of non-primitive array types, if appropriate. * * @param typeSpec Type of the attribute that might need to be initialized. * @param elementName Name of the attribute that might need to be initialized. */ static void idl_ifArrayInitializeElements( idl_typeSpec typeSpec, const char *elementName) { int dimCount = 1; int indent = 8; while (idl_typeSpecType(typeSpec) == idl_ttypedef) { typeSpec = idl_typeDefRefered(idl_typeDef(typeSpec)); } if ( idl_typeSpecType(typeSpec) == idl_tarray) { if (idl_arrayElementsNeedInitialization(idl_typeArray(typeSpec))) { idl_arrayElementInit( typeSpec, elementName, dimCount, indent); } } }
/** @brief callback function called on definition of a structure member in the IDL input file. * * Generate code for the following IDL construct: * @verbatim struct <structure-name> { => <structure-member-1>; => ... ... => <structure-member-n>; }; @endverbatim * * @param scope Current scope * @param name Name of the structure member * @param typeSpec Type specification of the structure member */ static void idl_structureMemberOpenClose ( idl_scope scope, const char *name, idl_typeSpec typeSpec, void *userData) { struct idl_genSACPPData *arg = (struct idl_genSACPPData *)userData; char *memberName; char *scopedName; char *seqName; switch (idl_typeSpecType(typeSpec)) { case idl_tbasic: case idl_tenum: case idl_ttypedef: case idl_tstruct: case idl_tunion: case idl_tseq: /* nothing todo */ break; case idl_tarray: /* generate implementation code for the array mapping */ memberName = idl_cxxId(name); snprintf(arg->buffer,MAX_BUFFER,"_%s_array",memberName); seqName = os_strdup(arg->buffer); scopedName = idl_scopeStackCxx(scope, "::", seqName); idl_arrayTypeImpl(idl_typeArray(typeSpec), scopedName,arg); snprintf(arg->buffer, MAX_BUFFER, "_%s_array %s;\n", memberName, memberName); os_free(seqName); os_free(scopedName); os_free(memberName); break; default: printf("idl_structureMemberOpenClose: Unsupported structure member type (member name = %s, type name = %s)\n", name, idl_scopedTypeName(typeSpec)); } }
/* Return the C specific type identifier for the specified type specification */ c_char * idl_corbaJavaTypeFromTypeSpec ( idl_typeSpec typeSpec) { c_char *typeName = NULL; /* QAC EXPECT 3416; No side effects here */ if (idl_typeSpecType(typeSpec) == idl_tbasic) { /* if the specified type is a basic type */ switch (idl_typeBasicType(idl_typeBasic(typeSpec))) { case idl_short: case idl_ushort: typeName = os_strdup("short"); break; case idl_long: case idl_ulong: typeName = os_strdup("int"); break; case idl_longlong: case idl_ulonglong: typeName = os_strdup("long"); break; case idl_float: typeName = os_strdup("float"); break; case idl_double: typeName = os_strdup("double"); break; case idl_char: typeName = os_strdup("char"); break; case idl_string: typeName = os_strdup("java.lang.String"); break; case idl_boolean: typeName = os_strdup("boolean"); break; case idl_octet: typeName = os_strdup("byte"); break; default: /* No processing required, empty statement to satisfy QAC */ break; /* QAC EXPECT 2016; Default case must be empty here */ } /* QAC EXPECT 3416; No side effects here */ } else if (idl_typeSpecType(typeSpec) == idl_tseq) { return idl_corbaJavaTypeFromTypeSpec (idl_typeSeqActual(idl_typeSeq (typeSpec))); } else if (idl_typeSpecType(typeSpec) == idl_tarray) { #if 0 /* sequence does not have an identification */ typeName = os_strdup (""); printf ("idl_corbaJavaTypeFromTypeSpec: Unexpected type handled\n"); #else return idl_corbaJavaTypeFromTypeSpec (idl_typeArrayActual(idl_typeArray (typeSpec))); #endif } else if (idl_typeSpecType(typeSpec) == idl_ttypedef) { return idl_corbaJavaTypeFromTypeSpec (idl_typeDefActual(idl_typeDef (typeSpec))); } else { /* if a user type is specified build it from its scope and its name. The type should be one of idl_ttypedef, idl_tenum, idl_tstruct, idl_tunion. */ typeName = idl_scopeStackJava( idl_typeUserScope(idl_typeUser(typeSpec)), ".", idl_typeSpecName(typeSpec)); } return typeName; /* QAC EXPECT 5101; The switch statement is simple, therefor the total complexity is low */ }
/** @brief callback function called on definition of a named type in the IDL input file. * * Generate code for the following IDL construct: * @verbatim => typedef <type-name> <name>; @endverbatim * * This function generates a prototype for the helper function to * load the typedef metadata if the typedef is defined * within the global scope or the scope of a module. * The name of the metadata load function is: * @verbatim __<scope-elements>_<name>__load @endverbatim * If the type specification is idl_tbasic a standard mapping will be applied: * @verbatim typedef <basic-type-mapping> <scope-elements>_<name>; @endverbatim * If the type specification is a user defined idl_ttypedef, idl_tenum, * idl_tstruct or idl_tunion a scoped name mapping will be generated. * @verbatim <typedef-name> <name>; => typedef enum <scope-elements>_<typedef-name> <scope-elements>_<name>; <enum-name> <name>; => typedef enum <scope-elements>_<enum-name> <scope-elements>_<name>; <struct-name> <name>; => typedef struct <scope-elements>_<structure-name> <scope-elements>_<name>; <union-name> <name>; => typedef struct <scope-elements>_<union-name> <scope-elements>_<name>; @endverbatim * If the type specification is idl_tarray then generate a scoped name * with the array specifiers: * @verbatim <other-usertype-name> <name>[n1]..[nn]; => typedef <scope-elements>_<other-usertype-name> <scope-elements>_<name>[n1]..[nn]; <basic-type> <name>[n1]..[nn]; => typedef <basic-type-mapping> <scope-elements>_<name>[n1]..[nn]; sequence<spec> <name>[n1]..[nn]; => typedef c_array <scope-elements>_<name>[n1]..[nn]; sequence<spec,length> <name>[n1]..[nn]; => typedef c_array <scope-elements>_<name>[n1]..[nn]; @endverbatim * If the type specification is idl_tseq then generate a mapping on c_sequence: * @verbatim sequence<spec> <name>; => typedef c_sequence <scope-elements>_<name>; sequence<spec,length> <name>; => typedef c_sequence <scope-elements>_<name>; @endverbatim * * @param scope Current scope * @param name Specifies the name of the type * @param defSpec Specifies the type of the named type */ static void idl_typedefOpenClose( idl_scope scope, const char *name, idl_typeDef defSpec, void *userData) { if (idl_scopeStackSize(scope) == 0 || idl_scopeElementType (idl_scopeCur(scope)) == idl_tModule) { idl_fileOutPrintf( idl_fileCur(), "extern c_metaObject __%s__load (c_base base);\n", idl_scopeStack(scope, "_", name)); if (idl_typeSpecType(idl_typeDefActual(defSpec)) == idl_tstruct || idl_typeSpecType(idl_typeDefActual(defSpec)) == idl_tunion) { /* If this is a typedef of a struct or union */ /* define the prototype of the function for querying the keys */ idl_fileOutPrintf( idl_fileCur(), "extern const char * __%s__keys (void);\n", idl_scopeStack(scope, "_", name)); /* define the prototype of the function for querying scoped structure name */ idl_fileOutPrintf( idl_fileCur(), "extern const char * __%s__name (void);\n", idl_scopeStack(scope, "_", name)); } } if (idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_ttypedef || idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tenum || idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tstruct || idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tunion || idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tbasic) { /* generate code for a standard mapping or a typedef, enum, struct or union user-type mapping */ idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "typedef %s _%s;\n\n", idl_scopedSplTypeIdent(idl_typeSpec(idl_typeDefRefered(defSpec))), idl_scopeStack (scope, "_", name)); } else if (idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tarray) { /* generate code for an array mapping */ idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "typedef %s _%s", idl_scopedSplTypeIdent(idl_typeArrayActual (idl_typeArray(idl_typeDefRefered(defSpec)))), idl_scopeStack(scope, "_", name)); idl_arrayDimensions(idl_typeArray(idl_typeDefRefered(defSpec)), OS_FALSE); idl_fileOutPrintf(idl_fileCur(), ";\n\n"); } else if (idl_typeSpecType(idl_typeSpec(idl_typeDefRefered(defSpec))) == idl_tseq) { /* generate code for a sequence mapping */ idl_printIndent(indent_level); if (idl_typeSeqMaxSize (idl_typeSeq(idl_typeDefRefered(defSpec))) == 0) { /* unbounded sequence */ idl_fileOutPrintf( idl_fileCur(), "typedef c_sequence _%s", idl_scopeStack (scope, "_", name)); } else { /* bounded sequence */ idl_fileOutPrintf( idl_fileCur(), "typedef c_sequence _%s", idl_scopeStack(scope, "_", name)); } idl_fileOutPrintf (idl_fileCur(), ";\n\n"); } else { printf("idl_typedefOpenClose: Unsupported typedef type (typename = %s, type = %s)\n", name, idl_scopedTypeName(idl_typeSpec(defSpec))); } }
/** @brief callback function called on definition of a named type in the IDL input file. * * Generate code for the following IDL construct: * @verbatim => typedef <type-name> <name>; @endverbatim * * @param scope Current scope * @param name Specifies the name of the type * @param defSpec Specifies the type of the named type */ static void idl_typedefOpenClose( idl_scope scope, const char *name, idl_typeDef defSpec, void *userData) { int nameLen = strlen(idl_javaId(name)) + strlen("Holder") + 1; char *holderName; if (idl_typeSpecType(idl_typeDefRefered (defSpec)) == idl_tseq) { holderName = os_malloc(nameLen); snprintf(holderName, nameLen, "%sHolder", idl_javaId(name)); /* Open file for used scope, if needed create the directories */ idl_openJavaPackage(scope, holderName); if (idl_fileCur() == NULL) { return; } if (idl_scopeStackSize(scope) > 0) { idl_fileOutPrintf( idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL)); idl_fileOutPrintf(idl_fileCur(), "\n"); } idl_fileOutPrintf(idl_fileCur(), "public final class %s\n{\n\n", holderName); idl_fileOutPrintf( idl_fileCur(), " public %s%s value = null;\n\n", idl_corbaJavaTypeFromTypeSpec(idl_typeSeqActual(idl_typeSeq(idl_typeDefRefered(defSpec)))), idl_sequenceIndexString (idl_typeSeq (idl_typeDefRefered (defSpec)))); idl_fileOutPrintf(idl_fileCur(), " public %s () { }\n\n", holderName); idl_fileOutPrintf( idl_fileCur(), " public %s (%s%s initialValue)\n", holderName, idl_corbaJavaTypeFromTypeSpec(idl_typeSeqActual(idl_typeSeq(idl_typeDefRefered(defSpec)))), idl_sequenceIndexString(idl_typeSeq (idl_typeDefRefered (defSpec)))); idl_fileOutPrintf(idl_fileCur(), " {\n"); idl_fileOutPrintf(idl_fileCur(), " value = initialValue;\n"); idl_fileOutPrintf(idl_fileCur(), " }\n\n"); idl_fileOutPrintf(idl_fileCur(), "}\n"); /* close file */ idl_closeJavaPackage(); } else if (idl_typeSpecType(idl_typeDefRefered (defSpec)) == idl_tarray) { holderName = os_malloc(nameLen); snprintf(holderName, nameLen, "%sHolder", idl_javaId(name)); /* Open file for used scope, if needed create the directories */ idl_openJavaPackage(scope, holderName); if (idl_fileCur() == NULL) { return; } if (idl_scopeStackSize(scope) > 0) { idl_fileOutPrintf( idl_fileCur(), "package %s;\n", idl_scopeStackJava(scope, ".", NULL)); idl_fileOutPrintf(idl_fileCur(), "\n"); } idl_fileOutPrintf(idl_fileCur(), "public final class %s\n{\n\n", holderName); idl_fileOutPrintf( idl_fileCur(), " public %s%s value = null;\n\n", idl_corbaJavaTypeFromTypeSpec(idl_typeArrayActual(idl_typeArray(idl_typeDefRefered(defSpec)))), idl_arrayJavaIndexString (idl_typeArray (idl_typeDefRefered (defSpec)))); idl_fileOutPrintf(idl_fileCur(), " public %s () { }\n\n", holderName); idl_fileOutPrintf( idl_fileCur(), " public %s (%s%s initialValue)\n", holderName, idl_corbaJavaTypeFromTypeSpec(idl_typeArrayActual(idl_typeArray(idl_typeDefRefered(defSpec)))), idl_arrayJavaIndexString(idl_typeArray (idl_typeDefRefered (defSpec)))); idl_fileOutPrintf(idl_fileCur(), " {\n"); idl_fileOutPrintf(idl_fileCur(), " value = initialValue;\n"); idl_fileOutPrintf(idl_fileCur(), " }\n\n"); idl_fileOutPrintf(idl_fileCur(), "}\n"); /* close file */ idl_closeJavaPackage(); } }
/** @brief callback function called on definition of a named type in the IDL input file. * * Generate code for the following IDL construct: * @verbatim => typedef <type-name> <name>; @endverbatim * * @param scope Current scope * @param name Specifies the name of the type * @param defSpec Specifies the type of the named type */ static void idl_typedefOpenClose( idl_scope scope, const char *name, idl_typeDef defSpec, void *userData) { struct idl_genSACPPData *arg = (struct idl_genSACPPData *)userData; idl_typeSpec actualType; idl_typeSpec refType; const char *refName; char *scopedName; actualType = idl_typeDefActual(defSpec); refType = idl_typeDefRefered(defSpec); refName = idl_typeSpecName(refType); scopedName = idl_corbaCxxTypeFromTypeSpec(idl_typeSpec(defSpec)); if (idl_typeSpecType(refType) == idl_tarray) { /* ex. typedef long myArr[22]; */ idl_arrayTypeImpl(idl_typeArray(refType), scopedName, arg); } else { if (idl_typeSpecType(actualType) == idl_tarray) { /* Generate implementation _alloc() method */ idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_slice *%s_alloc()\n", scopedName, scopedName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"return (%s_slice *)%s_alloc();\n", scopedName, refName); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); /* Generate implementation _free() method: * Implementation is independent of the actual type. */ idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"void %s_free(%s_slice *s)\n", scopedName, scopedName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"%s_free(s);\n", refName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); /* Generate implementation _copy() method */ idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"void *%s_copy(%s_slice *to, const %s_slice *from)\n", scopedName, scopedName, scopedName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"%s_copy(to, from);\n", refName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); /* Generate implementation _dup() method */ idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_slice *%s_dup(const %s_slice *from)\n", scopedName, scopedName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); arg->indent_level++; idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_slice *to = %s_alloc();\n", scopedName, scopedName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_copy(to, from);\n", refName); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"return to;\n"); arg->indent_level--; idl_fileOutPrintf(idl_fileCur(),"}\n\n"); } } os_free(scopedName); }
/* @brief generate initialization of array elements. * * idl_arrayElementInit generates for-loops that initialize * each attribute of an array explicitly. * * @param typeArray Specifies the type of the array */ static void idl_arrayElementInit( idl_typeSpec typeSpec, const char *elementName, int dimCount, int indent) { while (idl_typeSpecType(typeSpec) == idl_ttypedef) { typeSpec = idl_typeDefRefered(idl_typeDef(typeSpec)); } if (idl_typeSpecType(typeSpec) == idl_tarray) { idl_fileOutPrintf( idl_fileCur(), "%*sfor(int i%d = 0; i%d < %d; i%d++) {\n", indent, "", dimCount, dimCount, idl_typeArraySize(idl_typeArray(typeSpec)), dimCount); idl_arrayElementInit( idl_typeArrayType(idl_typeArray(typeSpec)), elementName, dimCount + 1, indent + 4); idl_fileOutPrintf( idl_fileCur(), "%*s}\n", indent, ""); } else { int j; idl_fileOutPrintf( idl_fileCur(), "%*s%s", indent, "", elementName); for (j = 1; j < dimCount; j++) { idl_fileOutPrintf(idl_fileCur(), "[i%d]", j); } if ( idl_typeSpecType(typeSpec) == idl_tbasic && idl_typeBasicType(idl_typeBasic(typeSpec)) == idl_string) { idl_fileOutPrintf( idl_fileCur(), " = \"\";\n"); } else if ( idl_typeSpecType(typeSpec) == idl_tunion || idl_typeSpecType(typeSpec) == idl_tstruct ) { idl_fileOutPrintf( idl_fileCur(), " = new %s();\n", idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else if (idl_typeSpecType(typeSpec) == idl_tenum) { idl_fileOutPrintf( idl_fileCur(), " = %s.from_int(0);\n", idl_corbaJavaTypeFromTypeSpec(typeSpec)); } } }
/** @brief callback function called on end of a structure definition in the IDL input file. * * Generate code for the following IDL construct: * @verbatim struct <structure-name> { <structure-member-1> ... ... <structure-member-n> => }; @endverbatim * * The structure is closed: * @verbatim }; @endverbatim * * @param name Name of the structure (not used) */ static void idl_structureClose( const char *name, void *userData) { idl_mapIter mapIter; idl_typeSpec typeSpec; char *memberName; /* build constructor <type-name> () {} */ idl_fileOutPrintf(idl_fileCur(), "\n"); idl_fileOutPrintf(idl_fileCur(), " public %s() {\n", idl_javaId(name)); mapIter = idl_mapFirst(map); while (idl_mapIterObject(mapIter)) { typeSpec = idl_mapIterObject(mapIter); memberName = idl_mapIterKey(mapIter); idl_ifArrayInitializeElements(typeSpec, memberName); idl_mapIterNext(mapIter); } idl_fileOutPrintf(idl_fileCur(), " }\n\n"); /* build constructor <type-name> (<arglist>) { <assignment-list> } */ idl_fileOutPrintf(idl_fileCur(), " public %s(\n", idl_javaId(name)); mapIter = idl_mapFirst(map); while (idl_mapIterObject(mapIter)) { typeSpec = idl_mapIterObject(mapIter); memberName = idl_mapIterKey(mapIter); if (idl_typeSpecType(typeSpec) == idl_tbasic) { idl_fileOutPrintf( idl_fileCur(), " %s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), memberName); } else if (idl_typeSpecType(typeSpec) == idl_tseq) { idl_fileOutPrintf( idl_fileCur(), " %s%s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_sequenceIndexString(idl_typeSeq(typeSpec)), memberName); } else if (idl_typeSpecType(typeSpec) == idl_tarray) { idl_fileOutPrintf( idl_fileCur(), " %s%s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_arrayJavaIndexString(idl_typeArray(typeSpec)), memberName); } else { if (idl_typeSpecType(typeSpec) == idl_ttypedef) { if (idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tbasic) { idl_fileOutPrintf( idl_fileCur(), " %s _%s", idl_corbaJavaTypeFromTypeSpec(idl_typeDefActual(idl_typeDef(typeSpec))), memberName); } else if (idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tseq) { idl_fileOutPrintf( idl_fileCur(), " %s%s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_sequenceIndexString(idl_typeSeq(idl_typeDefActual(idl_typeDef(typeSpec)))), memberName); } else if (idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tarray) { idl_fileOutPrintf( idl_fileCur(), " %s%s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_arrayJavaIndexString(idl_typeArray(idl_typeDefActual(idl_typeDef(typeSpec)))), memberName); } else { if ((idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tstruct) || (idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tunion) || (idl_typeSpecType(idl_typeDefActual(idl_typeDef(typeSpec))) == idl_tenum)) { idl_fileOutPrintf( idl_fileCur(), " %s _%s", idl_corbaJavaTypeFromTypeSpec(idl_typeDefActual(idl_typeDef(typeSpec))), idl_javaId(memberName)); } else { printf("idl_genSajType.c:idl_structureClose: Unexpected type %d\n", idl_typeSpecType (typeSpec)); } } } else { if ((idl_typeSpecType(typeSpec) == idl_tstruct) || (idl_typeSpecType(typeSpec) == idl_tunion) || (idl_typeSpecType(typeSpec) == idl_tenum)) { idl_fileOutPrintf( idl_fileCur(), " %s _%s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(memberName)); } else { printf("idl_genSajType.c:idl_structureClose: Unexpected type %d\n", idl_typeSpecType(typeSpec)); } } } idl_mapIterNext(mapIter); if (idl_mapIterObject(mapIter)) { idl_fileOutPrintf(idl_fileCur(), ",\n"); } else { idl_fileOutPrintf(idl_fileCur(), ")\n"); } } idl_mapIterFree(mapIter); idl_fileOutPrintf(idl_fileCur(), " {\n"); mapIter = idl_mapFirst(map); while (idl_mapIterObject(mapIter)) { idl_fileOutPrintf( idl_fileCur(), " %s = _%s;\n", idl_mapIterKey(mapIter), idl_mapIterKey(mapIter)); idl_mapIterNext (mapIter); } idl_mapIterFree(mapIter); idl_fileOutPrintf(idl_fileCur(), " }\n\n"); /* close class */ idl_fileOutPrintf(idl_fileCur(), "}\n"); /* close file */ idl_closeJavaPackage(); /* remove iterator */ idl_mapFree(map); }
/** @brief callback function called on definition of a structure member in the IDL input file. * * Generate code for the following IDL construct: * @verbatim struct <structure-name> { => <structure-member-1>; => ... ... => <structure-member-n>; }; @endverbatim * * @param scope Current scope * @param name Name of the structure member * @param typeSpec Type specification of the structure member */ static void idl_structureMemberOpenClose( idl_scope scope, const char *name, idl_typeSpec typeSpec, void *userData) { /* Dereference possible typedefs first. */ while (idl_typeSpecType(typeSpec) == idl_ttypedef) { typeSpec = idl_typeDefRefered(idl_typeDef(typeSpec)); } /* generate type-name and field-name attribute */ if ((idl_typeSpecType(typeSpec) == idl_tbasic)) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); if (idl_typeBasicType(idl_typeBasic (typeSpec)) == idl_string) { idl_fileOutPrintf( idl_fileCur(), " public %s %s = \"\";\n", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(name)); } else { idl_fileOutPrintf( idl_fileCur(), " public %s %s;\n", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(name)); } } else if (idl_typeSpecType(typeSpec) == idl_tseq) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); /* Inline sequence definition */ idl_fileOutPrintf( idl_fileCur(), " public %s%s %s = new %s", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_sequenceIndexString(idl_typeSeq(typeSpec)), idl_javaId(name), idl_corbaJavaTypeFromTypeSpec(typeSpec)); java_arrayDimensions(typeSpec); idl_fileOutPrintf (idl_fileCur(), ";\n"); } else if (idl_typeSpecType(typeSpec) == idl_tarray) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); /* Inline array definition */ idl_fileOutPrintf( idl_fileCur(), " public %s%s %s = new %s", idl_corbaJavaTypeFromTypeSpec (typeSpec), idl_arrayJavaIndexString(idl_typeArray(typeSpec)), idl_javaId(name), idl_corbaJavaTypeFromTypeSpec (typeSpec)); java_arrayDimensions(typeSpec); idl_fileOutPrintf (idl_fileCur(), ";\n"); } else if (idl_typeSpecType(typeSpec) == idl_tstruct) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); idl_fileOutPrintf( idl_fileCur(), " public %s %s = new %s();\n", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(name), idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else if (idl_typeSpecType(typeSpec) == idl_tenum) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); idl_fileOutPrintf( idl_fileCur(), " public %s %s = %s.from_int(0);\n", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(name), idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else if (idl_typeSpecType (typeSpec) == idl_tunion) { /* store type-name and field-name in iterator (append) */ idl_mapAdd(map, idl_javaId(name), typeSpec); idl_fileOutPrintf( idl_fileCur(), " public %s %s = new %s();\n", idl_corbaJavaTypeFromTypeSpec(typeSpec), idl_javaId(name), idl_corbaJavaTypeFromTypeSpec(typeSpec)); } else { printf("idl_genSajType.c:idl_structureMemberOpenClose: Unexpected type %d\n", idl_typeSpecType(typeSpec)); } }
/* Return the scoped actual type specification where for the user types, scopes are separated by "_" chracters. IDL strings (bounded and unbounded) are mapped on: c_string, other basic types are mapped on corresponding splice types IDL structures are identified by: struct <scoped-struct-name> IDL unions are identified by: struct <scoped-union-name> becuase the union mapping is: struct <union-name> { <tag-type> _d; union { <union-case-specifications> } _u; } IDL enumerations are identified by: enum <scoped-enum-name> IDL typedefs are formed by the scoped type name IDL sequences are mapped on: c_sequence */ static c_char * idl_scopedSacSequenceElementTypeIdent ( const idl_typeSpec typeSpec) { c_char scopedTypeIdent[256]; /* QAC EXPECT 3416; No unexpected side effects here */ if (idl_typeSpecType(typeSpec) == idl_tbasic) { switch (idl_typeBasicType(idl_typeBasic(typeSpec))) { case idl_short: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_short"); break; case idl_ushort: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_unsigned_short"); break; case idl_long: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_long"); break; case idl_ulong: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_unsigned_long"); break; case idl_longlong: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_long_long"); break; case idl_ulonglong: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_unsigned_long_long"); break; case idl_float: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_float"); break; case idl_double: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_double"); break; case idl_char: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_char"); break; case idl_string: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_string"); break; case idl_boolean: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_boolean"); break; case idl_octet: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "DDS_octet"); break; default: os_strncpy (scopedTypeIdent, "", (size_t)sizeof(scopedTypeIdent)); } } else if (idl_typeSpecType(typeSpec) == idl_tstruct || idl_typeSpecType(typeSpec) == idl_tunion || idl_typeSpecType(typeSpec) == idl_tenum) { /* QAC EXPECT 3416; No unexpected side effects here */ snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_sacTypeFromTypeSpec(idl_typeSpec(typeSpec))); /* QAC EXPECT 3416; No unexpected side effects here */ } else if (idl_typeSpecType(typeSpec) == idl_ttypedef) { switch (idl_typeSpecType(idl_typeDefRefered (idl_typeDef(typeSpec)))) { case idl_tarray: case idl_tseq: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_sacTypeFromTypeSpec(typeSpec)); break; case idl_ttypedef: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_scopedSacSequenceTypeIdent(idl_typeDefRefered (idl_typeDef(typeSpec)))); break; default: snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_sacTypeFromTypeSpec(idl_typeDefActual(idl_typeDef(typeSpec)))); } /* QAC EXPECT 3416; No unexpected side effects here */ } else if (idl_typeSpecType(typeSpec) == idl_tarray) { snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_scopedSacSequenceTypeIdent (idl_typeArrayActual(idl_typeArray(typeSpec)))); } else if (idl_typeSpecType(typeSpec) == idl_tseq) { snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s", idl_sequenceIdent(idl_typeSeq(typeSpec))); } else { /* Do nothing, only to prevent dangling else-ifs QAC messages */ } return os_strdup(scopedTypeIdent); }
/** @brief callback function called on definition of a structure member in the IDL input file. * * Generate code for the following IDL construct: * @verbatim struct <structure-name> { => <structure-member-1>; => ... ... => <structure-member-n>; }; @endverbatim * * If the type specification is idl_tbasic a standard mapping can be generated: * @verbatim string <name>; => c_string <name>; string <name,length>; => c_string <name>; char <name>; => c_char <name>; octet <name>; => c_octet <name>; short <name>; => c_short <name>; unsigned short <name>; => c_ushort <name>; long <name>; => c_long <name>; unsigned long <name>; => c_ulong <name>; long long <name>; => c_longlong <name>; unsigned long long <name>; => c_ulonglong <name>; float <name>; => c_float <name>; double <name>; => c_double <name>; boolean <name>; => c_bool <name>; @endverbatim * If the type specification is a user defined idl_ttypedef, idl_tenum, * idl_tstruct or idl_tunion a scoped name mapping will be generated. * @verbatim <typedef-name> <name>; => enum <scope-elements>_<typedef-name> <name>; <enum-name> <name>; => enum <scope-elements>_<enum-name> <name>; <struct-name> <name>; => struct <scope-elements>_<structure-name> <name>; <union-name> <name>; => struct <scope-elements>_<union-name> <name>; @endverbatim * If the type specification is idl_tarray then generate a scoped name * with the array specifiers: * @verbatim <other-usertype-name> <name>[n1]..[nn]; => <scope-elements>_<other-usertype-name> <name>[n1]..[nn]; <basic-type> <name>[n1]..[nn]; => <basic-type-mapping> <name>[n1]..[nn]; sequence<spec> <name>[n1]..[nn]; => c_array <name>[n1]..[nn]; sequence<spec,length> <name>[n1]..[nn]; => c_array <name>[n1]..[nn]; @endverbatim * If the type specification is idl_tseq then generate a mapping on c_sequence: * @verbatim sequence<spec> <name>; => c_sequence <name>; sequence<spec,length> <name>; => c_sequence <name,length>; @endverbatim * * @param scope Current scope * @param name Name of the structure member * @param typeSpec Type specification of the structure member */ static void idl_structureMemberOpenClose( idl_scope scope, const char *name, idl_typeSpec typeSpec, void *userData) { if (idl_typeSpecType(typeSpec) == idl_ttypedef|| idl_typeSpecType(typeSpec) == idl_tenum || idl_typeSpecType(typeSpec) == idl_tstruct || idl_typeSpecType(typeSpec) == idl_tunion || idl_typeSpecType(typeSpec) == idl_tbasic) { os_boolean catsRequested = OS_FALSE; os_boolean stacRequested = OS_FALSE; idl_typeSpec baseTypeDereffered = NULL; idl_typeSpec typeDereffered; /* is a stac pragma defined for this member? */ stacRequested = idl_stacDef_isStacDefined(scope, name, typeSpec, &baseTypeDereffered); if(!stacRequested) { /* Cats and stac def can not be defined over the same member as * one excepts string types and the other char (array) types */ catsRequested = idl_catsDef_isCatsDefined(scope, name, typeSpec); } if(catsRequested) { assert(!stacRequested); typeDereffered = idl_typeDefResolveFully(typeSpec); idl_structureMemberOpenClose(scope, name, typeDereffered, userData); } else if(stacRequested) { assert(baseTypeDereffered); typeDereffered = idl_typeDefResolveFully(typeSpec); idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "c_char %s", idl_languageId (name)); /* potential array bounds */ if((idl_typeSpecType(typeDereffered) == idl_tarray)) { idl_arrayDimensions(idl_typeArray(typeDereffered), OS_TRUE); } idl_fileOutPrintf(idl_fileCur(), "[%d];\n", idl_typeBasicMaxlen(idl_typeBasic(baseTypeDereffered))+1); } else { /* generate code for a standard mapping or a typedef, enum, struct or union user-type mapping */ idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "%s %s;\n", idl_scopedSplTypeIdent(typeSpec), idl_languageId(name)); } } else if (idl_typeSpecType(typeSpec) == idl_tarray) { /* generate code for an array mapping */ os_boolean catsRequested = OS_FALSE; os_boolean stacRequested = OS_FALSE; idl_typeSpec baseTypeDereffered = NULL; /* is a stac pragma defined for this member? */ stacRequested = idl_stacDef_isStacDefined(scope, name, typeSpec, &baseTypeDereffered); if(!stacRequested) { /* Cats and stac def can not be defined over the same member as * one excepts string types and the other char (array) types */ catsRequested = idl_catsDef_isCatsDefined(scope, name, typeSpec); } if(catsRequested) { assert(!stacRequested); idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "c_string %s;\n", idl_languageId(name)); } else if(stacRequested) { assert(!catsRequested); idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "c_char %s", idl_languageId(name)); idl_arrayDimensions(idl_typeArray(typeSpec), OS_TRUE); idl_fileOutPrintf(idl_fileCur(),"[%d]", idl_typeBasicMaxlen(idl_typeBasic(baseTypeDereffered))+1); idl_fileOutPrintf(idl_fileCur(), ";\n"); } else { idl_printIndent(indent_level); if (idl_typeSpecType(idl_typeArrayActual (idl_typeArray(typeSpec))) != idl_tseq) { idl_fileOutPrintf( idl_fileCur(), "%s %s", idl_scopedSplTypeIdent(idl_typeArrayActual(idl_typeArray(typeSpec))), idl_languageId(name)); } else { idl_fileOutPrintf(idl_fileCur(), "c_array %s", idl_languageId (name)); } idl_arrayDimensions(idl_typeArray(typeSpec), OS_FALSE); idl_fileOutPrintf(idl_fileCur(), ";\n"); } } else if (idl_typeSpecType(typeSpec) == idl_tseq) { /* generate code for a sequence mapping */ idl_printIndent(indent_level); if (idl_typeSeqMaxSize (idl_typeSeq(typeSpec)) == 0) { /* unbounded sequence */ idl_fileOutPrintf(idl_fileCur(), "c_sequence %s", idl_languageId(name)); } else { /* bounded sequence */ idl_fileOutPrintf (idl_fileCur(), "c_sequence %s", idl_languageId(name)); } idl_fileOutPrintf (idl_fileCur(), ";\n"); } else { printf ("idl_structureMemberOpenClose: Unsupported structure member type (member name = %s, type name = %s)\n", name, idl_scopedTypeName(typeSpec)); } }