static idl_action
idl_unionOpen(
idl_scope scope,
const char *name,
idl_typeUnion unionSpec,
void *userData)
{
c_char spaces[20];
idl_tmplExp te;
OS_UNUSED_ARG(unionSpec);
OS_UNUSED_ARG(userData);
/* QAC EXPECT 3416; No side effects here */
if (idl_streamsResolve(idl_streamsDefDefGet(), scope, name)) {
/* keylist defined for this union */
te = idl_tmplExpNew(idlpp_macroSet);
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scopedtypename", idl_scopeStack(scope, "::", name)));
snprintf(spaces, sizeof(spaces), "%d", idlpp_indent_level*4);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
}
return idl_abort;
}
static void
idl_typedefOpenClose(
idl_scope scope,
const char *name,
idl_typeDef defSpec,
void *userData)
{
c_char spaces[20];
idl_tmplExp te;
OS_UNUSED_ARG(userData);
if ((idl_typeSpecType(idl_typeDefRefered(defSpec)) == idl_tstruct ||
(idl_typeSpecType(idl_typeDefRefered(defSpec)) == idl_tunion)) &&
(idl_streamsResolve(idl_streamsDefDefGet(), scope, name))) {
/* keylist defined for this typedef of struct or union */
te = idl_tmplExpNew(idlpp_macroSet);
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("scopedtypename", idl_scopeStack(scope, "::", name)));
snprintf(spaces, sizeof(spaces), "%d", idlpp_indent_level*4);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
}
}
static idl_action
idl_structureOpen(
idl_scope scope,
const char *name,
idl_typeStruct structSpec,
void *userData)
{
c_char spaces[20];
idl_tmplExp te;
CxxTypeUserData *cxxUserData = (CxxTypeUserData *)userData;
/* QAC EXPECT 3416; No side effects here */
if (idl_keyResolve(idl_keyDefDefGet(), scope, name) != NULL) {
/* keylist defined for this struct */
te = idl_tmplExpNew(idlpp_macroSet);
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew("cnamescope", idl_scopeStack(scope, "_", "")));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
snprintf(spaces, sizeof(spaces), "%d", idlpp_indent_level*4);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
/* Store data-type in iterator for future generation of type descriptor. */
idl_metaCxxAddType(scope, name, idl_typeSpec(structSpec), &cxxUserData->idlpp_metaList);
}
return idl_abort;
}
static idl_action
idl_structureOpen(
idl_scope scope,
const char *name,
idl_typeStruct structSpec,
void *userData)
{
c_char spaces[20];
idl_tmplExp te;
/* QAC EXPECT 3416; No side effects here */
if (idl_keyResolve(idl_keyDefDefGet(), scope, name) != NULL) {
/* keylist defined for this struct */
te = idl_tmplExpNew(idlpp_macroSet);
idl_macroSetAdd(idlpp_macroSet,
idl_macroNew("namescope", idl_cxxId(idl_scopeElementName(idl_scopeCur(scope)))));
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("typename", idl_cxxId(name)));
snprintf(spaces, (size_t)sizeof(spaces), "%d", idlpp_indent_level*4);
idl_macroSetAdd(idlpp_macroSet, idl_macroNew("spaces", spaces));
idlpp_inStream = idl_streamInNew(idlpp_template, idlpp_macroAttrib);
idl_tmplExpProcessTmpl(te, idlpp_inStream, idl_fileCur());
idl_streamInFree(idlpp_inStream);
idl_tmplExpFree(te);
}
return idl_abort;
}
/** @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;
}
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;
}
/** @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;
}
/** @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;
}
