static void
idl_typedefOpenClose(
idl_scope scope,
const char *name,
idl_typeDef defSpec,
void *userData)
{
if ((idl_typeSpecType(idl_typeDefActual (defSpec)) == idl_tstruct) ||
(idl_typeSpecType(idl_typeDefActual (defSpec)) == idl_tunion)) {
if (idl_keyResolve(idl_keyDefDefGet(), scope, name) != NULL) {
newMeta(scope, name, idl_typeSpec(defSpec));
}
}
}
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);
}
static void
idl_typedefOpenClose(
idl_scope scope,
const char *name,
idl_typeDef defSpec,
void *userData)
{
if ((idl_typeSpecType(idl_typeDefActual (defSpec)) == idl_tstruct) ||
(idl_typeSpecType (idl_typeDefActual (defSpec)) == idl_tunion)) {
if (idl_keyResolve(idl_keyDefDefGet(), scope, name) != NULL) {
idl_genInterface(scope, name, "TypeSupport", idl_typeSpec(defSpec), FALSE);
idl_genInterface(scope, name, "DataReader", idl_typeSpec(defSpec), TRUE);
idl_genInterface(scope, name, "DataReaderView", idl_typeSpec(defSpec), TRUE);
idl_genInterface(scope, name, "DataWriter", idl_typeSpec(defSpec), TRUE);
idl_genTypeSeqHolder(scope, name, idl_typeDefActual(defSpec));
}
}
}
/* typedefOpen callback
A typedef of a structure or union is a type that can be
communicated via the DCPS API.
For the typedef the following helper functions are defined:
- a function to query the typedef scoped type name
- a function to query the typedef key list
The name of the functions are:
__<scope-elements>_<typedef-name>__name
and
__<scope-elements>_<typedef-name>__keys
respectively.
*/
static void
idl_typedefOpenClose (
idl_scope scope,
const char *name,
idl_typeDef defSpec,
void *userData)
{
switch (idl_typeSpecType(idl_typeDefActual(defSpec))) {
case idl_tstruct:
idl_structureOpen(scope, name, idl_typeStruct(idl_typeDefActual(defSpec)), userData);
break;
case idl_tunion:
idl_unionOpen(scope, name, idl_typeUnion(idl_typeDefActual(defSpec)), userData);
break;
default:
/* Empty statement to satisfy QAC */
idl_null();
break;
}
}
/** @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;
}
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;
}
static void
newMeta(
idl_scope scope,
const char *name,
idl_typeSpec typeSpec)
{
idl_meta meta;
meta = os_malloc(C_SIZEOF(idl_meta));
if (meta) {
meta->scope = idl_scopeDup(scope);
meta->name = os_strdup(name);
if (idl_typeSpecType(typeSpec) == idl_ttypedef) {
meta->actual_name = idl_typeSpecName(idl_typeDefActual(idl_typeDef(typeSpec)));
} else {
meta->actual_name = idl_typeSpecName(typeSpec);
}
meta->type = idl_typeSpecDef(typeSpec);
}
idlpp_metaList = os_iterAppend(idlpp_metaList, meta);
}
/* 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 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);
}
/* 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 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 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)));
}
}
