static c_char * idl_scopeJavaElementName ( idl_scopeElement scope) { c_char *scopeName; c_char *scopeJavaName; scopeName = idl_scopeElementName(scope); if ((idl_scopeElementType(scope) == idl_tStruct) || (idl_scopeElementType(scope) == idl_tUnion)) { scopeJavaName = os_malloc(strlen(scopeName) + 8); sprintf(scopeJavaName, "%sPackage", scopeName); } else { scopeJavaName = scopeName; } return scopeJavaName; }
/* Find the key list related to the specified typename in the specified scope */ c_char * idl_keyResolve ( idl_keyDef keyDef, idl_scope scope, const char *typeName) { c_long li; c_long si; idl_keyMap keyMap; c_metaObject typeScope; li = 0; /* check all key definition list elements */ while (li < c_iterLength (keyDef->keyList)) { keyMap = c_iterObject (keyDef->keyList, li); if (strcmp(typeName, keyMap->typeName) == 0) { /* if the typename equals, check if the scope compares */ if ((idl_scopeStackSize(scope) == 0) && (keyMap->scope->definedIn == NULL)) { /* Global scope */ return keyMap->keyList; } si = idl_scopeStackSize (scope)-1; typeScope = keyMap->scope; while (si >= 0) { /* for each scope element */ if (idl_scopeElementType(idl_scopeIndexed (scope, si)) == idl_tModule && strcmp (typeScope->name, idl_scopeElementName(idl_scopeIndexed (scope, si))) == 0) { /* the scope is a module and the scope name compares */ si--; if (typeScope) { typeScope = typeScope->definedIn; } if (si == -1) { /* bottom of the stack is reached */ if (typeScope == NULL || typeScope->name == NULL) { /* the typeScope has reached the bottom too, thus the scopes are equal */ return keyMap->keyList; } } } else { si = -1; } } } li++; } return NULL; }
/** @brief callback function called on definition of a union 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 * * This function generates prototypes for the helper functions to * load the unions metadata, to determine the unions keys and the * scoped name of the union if the union is defined in the global * scope or within a module. * The name of the metadata load function is: * @verbatim __<scope-elements>_<structure-name>__load @endverbatim * The name of the key query function is: * @verbatim __<scope-elements>_<union-name>__keys @endverbatim * The name of the name query function is: * @verbatim __<scope-elements>_<union-name>__name @endverbatim * If the union is defined within another union or within a * struct, no key nor its name can be queried. Such a union * can not be communicated via Splice as a separate entity. * IDL unions are mapped onto C structs for Splice in the * following manner: * @verbatim struct <union-name> { <switch-type> _d; union { <union-case-1>; ... ... <union-case-m>; } _u; }; @endverbatim * The union definition is opened: * @verbatim struct <scope-elements>_<name> { @endverbatim * Then depending on the type of the switch (integral type is required) any of the following: * @verbatim enum <enum-type> _d; // for an enumeration <scope-elements>_<typedef-name> _d; // for an typedeffed enum or basic type <basic-type-mapping> _d; // for an integral basic type @endverbatim * Then open the union part: * @verbatim union { @endverbatim * * @param scope Current scope * @param name Name of the union * @param unionSpec Specifies the number of union cases and the union switch type * @return Next action for this union (idl_explore) */ static idl_action idl_unionOpen( idl_scope scope, const char *name, idl_typeUnion unionSpec, void *userData) { if (idl_scopeStackSize(scope) == 0 || idl_scopeElementType (idl_scopeCur(scope)) == idl_tModule) { /* define the prototype of the function for metadata load */ idl_fileOutPrintf(idl_fileCur(), "extern c_metaObject __%s__load (c_base base);\n", idl_scopeStack(scope, "_", name)); /* 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 union name */ idl_fileOutPrintf(idl_fileCur(), "extern const char * __%s__name (void);\n", idl_scopeStack(scope, "_", name)); } /* open the struct */ idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "struct _%s {\n", idl_scopeStack(scope, "_", name)); indent_level++; /* generate code for the switch */ if (idl_typeSpecType(idl_typeUnionSwitchKind(unionSpec)) == idl_tbasic) { idl_printIndent(indent_level); idl_fileOutPrintf (idl_fileCur(), "%s _d;\n", idl_scopedTypeName(idl_typeUnionSwitchKind(unionSpec))); } else if (idl_typeSpecType(idl_typeUnionSwitchKind(unionSpec)) == idl_tenum) { idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "%s _d;\n", idl_scopedSplTypeName(idl_typeUnionSwitchKind(unionSpec))); } else if (idl_typeSpecType(idl_typeUnionSwitchKind(unionSpec)) == idl_ttypedef) { switch (idl_typeSpecType(idl_typeDefActual(idl_typeDef(idl_typeUnionSwitchKind(unionSpec))))) { case idl_tbasic: case idl_tenum: idl_printIndent(indent_level); idl_fileOutPrintf (idl_fileCur(), "%s _d;\n", idl_scopedSplTypeName(idl_typeUnionSwitchKind(unionSpec))); break; default: printf ("idl_unionOpen: Unsupported switchkind\n"); } } else { printf ("idl_unionOpen: Unsupported switchkind\n"); } /* open the union */ idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "union {\n"); indent_level++; /* return idl_explore to indicate that the rest of the union needs to be processed */ return idl_explore; }
/** @brief callback function called on definition of an enumeration. * * Generate code for the following IDL construct: * @verbatim => enum <enum-name> { <enum-element-1>; ... ... <enum-element-n>; }; @endverbatim * * This function generates a prototype for the helper function to * load the enumerations metadata if the enumeration is defined * within the global scope or the scope of a module. * The name of the metadata load function is: * @verbatim __<scope-elements>_<enum-name>__load @endverbatim * The enum definition is opened: * @verbatim enum <scope-elements>_<enum-name> { @endverbatim * @param scope Current scope * @param name Name of the enumeration * @param enumSpec Specifies the number of elements in the enumeration * @return Next action for this enumeration (idl_explore) */ static idl_action idl_enumerationOpen( idl_scope scope, const char *name, idl_typeEnum enumSpec, 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)); } idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "enum _%s {\n", idl_scopeStack (scope, "_", name)); enum_element = idl_typeEnumNoElements(enumSpec); indent_level++; /* return idl_explore to indicate that the rest of the enumeration needs to be processed */ return idl_explore; }
/* Find the stac list related to the specified typename in the specified scope */ os_boolean idl_stacListItemIsDefined ( idl_stacDef stacDef, idl_scope scope, const char *typeName, const char* itemName) { c_ulong li; c_long si; idl_stacMap stacMap; c_metaObject typeScope; os_boolean isDefined = OS_FALSE; if(stacDef) { li = 0; /* check all stac definition list elements */ while (li < c_iterLength (stacDef->stacList) && !isDefined) { stacMap = c_iterObject (stacDef->stacList, li); if (strcmp(typeName, stacMap->typeName) == 0) { /* if the typename equals, check if the scope compares */ if ((idl_scopeStackSize(scope) == 0) && (stacMap->scope->definedIn == NULL)) { /* We're in the global scope */ /* If no members were defined for this type, then we will * interprete this as a request for all bounded string * members to be converted to a char array internally. */ if(strlen(stacMap->stacList) == 0) { isDefined = OS_TRUE; } else if(idl_stacDefOnlyExclusionsDefined(stacMap->stacList)) { if(idl_stacDefIsFieldExcluded(stacMap->stacList, itemName)) { isDefined = OS_FALSE; } else { isDefined = OS_TRUE; } } else { isDefined = idl_stacListItemIsMemberLocated(stacMap->stacList, itemName); } } if(!isDefined) { si = idl_scopeStackSize (scope)-1; typeScope = stacMap->scope; while (si >= 0) { /* for each scope element */ if (idl_scopeElementType(idl_scopeIndexed (scope, si)) == idl_tModule && strcmp (typeScope->name, idl_scopeElementName(idl_scopeIndexed (scope, si))) == 0) { /* the scope is a module and the scope name compares */ si--; if (typeScope) { typeScope = typeScope->definedIn; } if (si == -1) { /* bottom of the stack is reached */ if (typeScope == NULL || typeScope->name == NULL) { /* the typeScope has reached the bottom too, * thus the scopes are equal */ /* If no members were defined for this type, then we will * interprete this as a request for all bounded string * members to be converted to a char array internally. */ if(strlen(stacMap->stacList) == 0) { isDefined = OS_TRUE; } else if(idl_stacDefOnlyExclusionsDefined(stacMap->stacList)) { if(idl_stacDefIsFieldExcluded(stacMap->stacList, itemName)) { isDefined = OS_FALSE; } else { isDefined = OS_TRUE; } } else { isDefined = idl_stacListItemIsMemberLocated(stacMap->stacList, itemName); } } } } else { si = -1; } } } } li++; } } return isDefined; }
/** @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 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 * * This function generates prototypes for the helper functions to * load the structures metadata, to determine the structures keys * and the scoped name of the struct if the struct is defined in * the global scope or within a module. * The name of the metadata load function is: * @verbatim __<scope-elements>_<structure-name>__load @endverbatim * The name of the key query function is: * @verbatim __<scope-elements>_<structure-name>__keys @endverbatim * The name of the name query function is: * @verbatim __<scope-elements>_<structure-name>__name @endverbatim * If the struct is defined within another struct or within a * union, no key nor its name can be queried. Such a structure * can not be communicated via Splice as a separate entity. * IDL structs are mapped onto C structs for Splice, therefor * a struct definition is opened: * @verbatim struct <scope-elements>_<name> { @endverbatim * * @param scope Current scope (and scope of the structure definition) * @param name Name of the structure * @param structSpec Specification of the struct holding the amount of members * @return Next action for this structure (idl_explore) */ static idl_action idl_structureOpen( idl_scope scope, const char *name, idl_typeStruct structSpec, void *userData) { if (idl_scopeStackSize(scope) == 0 || idl_scopeElementType (idl_scopeCur(scope)) == idl_tModule) { /* define the prototype of the function for metadata load */ idl_fileOutPrintf(idl_fileCur(), "extern c_metaObject __%s__load (c_base base);\n", idl_scopeStack(scope, "_", name)); /* 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(!test_mode) { /* define the prototype of the function for performing copyIn/copyOut. This needs to be * exported as well to ensure it can be access by other (ussually also OpenSplice * generated) packages */ idl_fileOutPrintf( idl_fileCur(), "struct _%s ;\n", idl_scopeStack(scope, "_", name)); if(useVoidPtrs) { idl_fileOutPrintf( idl_fileCur(), "extern %s c_bool __%s__copyIn(c_base base, void *from, void *to);\n", idl_dllGetMacro(), idl_scopeStack(scope, "_", name)); } else { idl_fileOutPrintf( idl_fileCur(), "extern %s c_bool __%s__copyIn(c_base base, struct %s *from, struct _%s *to);\n", idl_dllGetMacro(), idl_scopeStack(scope, "_", name), idl_scopeStack(scope, "::", name), idl_scopeStack(scope, "_", name)); } idl_fileOutPrintf( idl_fileCur(), "extern %s void __%s__copyOut(void *_from, void *_to);\n", idl_dllGetMacro(), idl_scopeStack(scope, "_", name)); } } idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "struct _%s {\n", idl_scopeStack(scope, "_", name)); indent_level++; /* return idl_explore to indicate that the rest of the structure needs to be processed */ return idl_explore; }