/** @brief callback function called on closure 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 * * The union is closed: * @verbatim } _u; }; @endverbatim * @param name Name of the union */ static void idl_unionClose ( const char *name, void *userData) { indent_level--; idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "} _u;\n"); indent_level--; idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "};\n\n"); }
/** @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)); } }
/** @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; }
static void idl_moduleClose( void *userData) { idlpp_indent_level--; idl_printIndent(idlpp_indent_level); idl_fileOutPrintf(idl_fileCur(), "}\n"); idl_fileOutPrintf(idl_fileCur(), "\n"); }
static idl_action idl_moduleOpen ( idl_scope scope, const char *name, void *userData) { c_ulong streamsIndex, streamsCount; idl_action result; OS_UNUSED_ARG(userData); OS_UNUSED_ARG(userData); /* Test whether the module contains a component within the pragma streams. * If it does not, then the module should not be generated since it will * contain no items (which is itself illegal idl syntax). * * Note that we are comparing against only the streams existing within this idl * file (idl_idlScopeStreamsList). We do not use the result of idl_keyDefDefGet() * since this is a list of streams resulting from the preprocessed idl (which * will include streams from other idl files that this may include). */ result = idl_abort; streamsCount = os_iterLength(idl_idlScopeStreamsList); if (streamsCount != 0) { idl_scope moduleScope; idl_scopeElement newElement; /* the idl_scope parameter to this function does not yet include the scoping * for this module itself, so create a duplicate and add this scoping to it, * before testing whether this module contains one of the streams in this file. */ moduleScope = idl_scopeDup(scope); newElement = idl_scopeElementNew(name, idl_tModule); idl_scopePush(moduleScope, newElement); /* Loop through the list of keys applying to this idl file and test whether * this particular module contains one of these keys. If it does, generate * code for the module. */ for (streamsIndex = 0; (streamsIndex < streamsCount) && (result == idl_abort); streamsIndex++) { idl_scope streamsScope = os_iterObject(idl_idlScopeStreamsList, streamsIndex); if (idl_scopeSub(moduleScope, streamsScope)) { /* Scopes match */ result = idl_explore; } } } if (result == idl_explore) { idl_printIndent(idlpp_indent_level); idl_fileOutPrintf(idl_fileCur(), "module %s {\n", idl_cxxId(name)); idl_fileOutPrintf(idl_fileCur(), "\n"); idlpp_indent_level++; } return result; }
static idl_action idl_moduleOpen ( idl_scope scope, const char *name, void *userData) { /* Test whether the module contains a component within the pragma keylist. * If it does not, then the module should not be generated since it will * contain no items (which is itself illegal idl syntax). * * Note that we are comparing against only the keys existing within this idl * file (idl_idlScopeKeyList). We do not use the result of idl_keyDefDefGet() * since this is a list of keys resulting from the preprocessed idl (which * will include keys from other idl files that this may include). */ if (os_iterLength (idl_idlScopeKeyList) == 0) { return idl_abort; } else { c_long li = 0; c_bool scopesMatch = FALSE; idl_scope moduleScope; idl_scopeElement newElement; /* the idl_scope parameter to this function does not yet include the scoping * for this module itself, so create a duplicate and add this scoping to it, * before testing whether this module contains one of the keys in this file. */ moduleScope = idl_scopeDup(scope); newElement = idl_scopeElementNew (name, idl_tModule); idl_scopePush (moduleScope, newElement); /* Loop through the list of keys applying to this idl file and test whether * this particular module contains one of these keys. If it does, generate * code for the module in the Dcps.idl file. */ while (li < os_iterLength (idl_idlScopeKeyList)) { idl_scope keyscope = os_iterObject (idl_idlScopeKeyList, li); scopesMatch = idl_scopeSub (moduleScope, keyscope); if (scopesMatch) { break; } li++; } if (scopesMatch == FALSE) { return idl_abort; } } idl_printIndent(idlpp_indent_level); idl_fileOutPrintf(idl_fileCur(), "module %s {\n", idl_cxxId(name)); idl_fileOutPrintf(idl_fileCur(), "\n"); idlpp_indent_level++; return idl_explore; }
/** @brief callback function called on definition of an enumeration element in the IDL input file. * * Generate code for the following IDL construct: * @verbatim enum <enum-name> { => <enum-element-1>, => ... ... => <enum-element-n> }; @endverbatim * * For the last element generate: * @verbatim <element-name> @endverbatim * For any but the last element generate: * @verbatim <element-name>, @endverbatim * * @param scope Current scope * @param name Name of the enumeration element */ static void idl_enumerationElementOpenClose( idl_scope scope, const char *name, void *userData) { enum_element--; if (enum_element == 0) { idl_printIndent(indent_level); idl_fileOutPrintf(idl_fileCur(), "_%s\n", idl_scopeStack(scope, "_", name)); } else { idl_printIndent(indent_level); idl_fileOutPrintf( idl_fileCur(), "_%s,\n", idl_scopeStack (scope, "_", name)); } }
static idl_action idl_moduleOpen( idl_scope scope, const char *name, void *userData) { idl_printIndent(idlpp_indent_level); idl_fileOutPrintf(idl_fileCur(), "namespace %s {\n", idl_cxxId(name)); idl_fileOutPrintf(idl_fileCur(), "\n"); idlpp_indent_level++; return idl_explore; }
static void idl_moduleClose( void *userData) { OS_UNUSED_ARG(userData); /* this is only executed if idl_moduleOpen returns 'idl_explore' */ OS_UNUSED_ARG(userData); idlpp_indent_level--; idl_printIndent(idlpp_indent_level); idl_fileOutPrintf(idl_fileCur(), "};\n"); idl_fileOutPrintf(idl_fileCur(), "\n"); }
/** @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; }
static void idl_arrayTypeImpl( idl_typeArray typeArray, const char *name, struct idl_genSACPPData *arg) { idl_typeSpec actualType; idl_typeSpec subType; c_ulong totalDim; actualType = idl_typeArrayActual(typeArray); subType = idl_typeArrayType(typeArray); /* determine total buffer len, by multiplying all dimensions */ totalDim = idl_genArrayTotalDimension(typeArray); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"template <>\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_slice *DDS_DCPS_ArrayHelper<%s, %s_slice, %s_uniq_>::alloc()\n", name, name, name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"return %s_alloc();\n", name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"template <>\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"void DDS_DCPS_ArrayHelper<%s, %s_slice, %s_uniq_>::copy(%s_slice *to, const %s_slice *from)\n", name, name, name, name, name); 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", name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"template <>\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"void DDS_DCPS_ArrayHelper<%s, %s_slice, %s_uniq_>::free(%s_slice *ptr)\n", name, name, name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"%s_free(ptr);\n", name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n\n"); /* Generate implementation _alloc() method */ idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_slice *%s_alloc()\n", name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); arg->indent_level++; if ((idl_typeSpecType(actualType) == idl_tbasic) && (idl_typeBasicType(idl_typeBasic(actualType)) == idl_string)) { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"::DDS::String_mgr *ret = (::DDS::String_mgr *) new ::DDS::String_mgr[%d];\n",totalDim); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"for (::DDS::ULong i = 0; i < %d; i++) {\n", totalDim); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"ret[i] = (::DDS::String)NULL;\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"return (%s_slice *)ret;\n"); } else { if (idl_typeSpecType(actualType) == idl_tseq) { /* \TODO */ } else { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s *ret = (%s *) new %s[%d];\n", idl_corbaCxxTypeFromTypeSpec(actualType), idl_corbaCxxTypeFromTypeSpec(actualType), idl_corbaCxxTypeFromTypeSpec(actualType), totalDim); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"return (%s_slice *)ret;\n", name); } } arg->indent_level--; idl_printIndent(arg->indent_level); 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", name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); arg->indent_level++; if ((idl_typeSpecType(actualType) == idl_tbasic) && (idl_typeBasicType(idl_typeBasic(actualType)) == idl_string)) { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"if (s) {\n"); arg->indent_level++; idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"::DDS::String_mgr *base = (::DDS::String_mgr *)s;\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"for (::DDS::ULong i = 0; i < %d; i++) {\n", totalDim); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"base[i] = (::DDS::String)NULL;\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n"); arg->indent_level--; idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"delete [] s;\n"); } else { if (idl_typeSpecType(actualType) == idl_tseq) { /* \TODO */ } else { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"delete [] s;\n"); } } arg->indent_level--; 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", name, name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"{\n"); arg->indent_level++; if ((idl_typeSpecType(actualType) == idl_tbasic) && (idl_typeBasicType(idl_typeBasic(actualType)) == idl_string)) { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"::DDS::String_mgr *sv = (::DDS::String_mgr *)from;\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"::DDS::String_mgr *tv = (::DDS::String_mgr *)to;\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"for (::DDS::ULong i = 0; i < %d; i++) {\n", totalDim); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"tv[i] = ::DDS::string_dup (sv[i]);\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n"); } else { if (idl_typeSpecType(actualType) == idl_tseq) { /* \TODO */ } else { idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s *sv = (%s *)from;\n", idl_corbaCxxTypeFromTypeSpec(actualType), idl_corbaCxxTypeFromTypeSpec(actualType)); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s *tv = (%s *)to;\n", idl_corbaCxxTypeFromTypeSpec(actualType), idl_corbaCxxTypeFromTypeSpec(actualType)); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"for (::DDS::ULong i = 0; i < %d; i++) {\n", totalDim); idl_printIndent(arg->indent_level+1); idl_fileOutPrintf(idl_fileCur(),"tv[i] = sv[i];\n"); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"}\n"); } } arg->indent_level--; 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", name, name, name); 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", name, name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"%s_copy(to, from);\n", name); idl_printIndent(arg->indent_level); idl_fileOutPrintf(idl_fileCur(),"return to;\n"); arg->indent_level--; idl_fileOutPrintf(idl_fileCur(),"}\n\n"); }
/** @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 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 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)); } }
/** @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; }