c_char *
idl_scopedSplTypeIdent (
const idl_typeSpec typeSpec)
{
c_char scopedTypeIdent[256];
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeSpecType(typeSpec) == idl_tbasic) {
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeBasicType (idl_typeBasic(typeSpec)) == idl_string) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "c_string");
} else {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "%s",
idl_typeSpecName(idl_typeSpec(typeSpec)));
}
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tenum) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "enum _%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tstruct) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "struct _%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tunion) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "struct _%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_ttypedef) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "_%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tseq) {
snprintf (scopedTypeIdent, (size_t)sizeof(scopedTypeIdent), "c_sequence");
} else {
/* Do nothing, only to prevent dangling else-ifs QAC messages */
}
return os_strdup(scopedTypeIdent);
}
/* Return the scoped type name where for the user types,
scopes are separated by "_" chracters.
*/
c_char *
idl_scopedTypeName (
const idl_typeSpec typeSpec)
{
const char *scopedTypeName;
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeSpecType(typeSpec) == idl_tseq) {
/* Sequences map to c_sequence */
scopedTypeName = "c_sequence";
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tbasic) {
/* For basic types take the corresponding type name supported by the splice database */
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeBasicType(idl_typeBasic(typeSpec)) == idl_string) {
/* in case of bounded string the type name must become c_string */
/* type name is of form "C_STRING<xx>" */
scopedTypeName = "c_string";
} else {
scopedTypeName = idl_typeSpecName(idl_typeSpec(typeSpec));
}
} else {
/* Build a name for user types from scope and its own name */
scopedTypeName = idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec)));
}
return os_strdup(scopedTypeName);
}
/* Return the C++ specific type identifier for the
specified type specification
*/
c_char *
idl_corbaCxxTypeFromTypeSpec(
idl_typeSpec typeSpec)
{
c_char *typeName;
/* QAC EXPECT 3416; No side effects here */
if (idl_typeSpecType(typeSpec) == idl_tbasic) {
/* if the specified type is a basic type */
if (idl_getCorbaMode() == IDL_MODE_STANDALONE) {
typeName = standaloneTypeFromTypeSpec(idl_typeBasic(typeSpec));
} else {
typeName = corbaTypeFromTypeSpec(idl_typeBasic(typeSpec));
}
} else if ((idl_typeSpecType(typeSpec) == idl_tseq) ||
(idl_typeSpecType(typeSpec) == idl_tarray)) {
/* sequence does not have an identification */
typeName = os_strdup ("");
printf ("idl_corbaCxxTypeFromTypeSpec: Unexpected type handled\n");
assert(0);
} 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_scopeStackCxx(
idl_typeUserScope(idl_typeUser(typeSpec)),
"::",
idl_typeSpecName(typeSpec));
}
return typeName;
/* QAC EXPECT 5101; The switch statement is simple, therefor the total complexity is low */
}
/**
* Not yet required
* @return idl_explore - Apparently this means process the rest of the file.
*/
static idl_action
idl_structureOpen(
idl_scope scope,
const char *name,
idl_typeStruct structSpec,
void *userData)
{
char* sampleType;
(void) scope;
(void) userData;
if (idl_keyResolve(idl_keyDefDefGet(), idl_typeUserScope(idl_typeUser(structSpec)), name) != NULL)
{
sampleType = idl_corbaCxxTypeFromTypeSpec(idl_typeSpec(structSpec));
idl_fileOutPrintf(idl_fileCur(),
"REGISTER_TOPIC_TRAITS(%s)\n",
sampleType);
/* Remove "StreamSample" for REGISTER_STREAM_TOPIC_TRAITS */
if(strlen(name) > 12 && strcmp(name+strlen(name)-12, "StreamSample")==0)
{
sampleType[strlen(sampleType)-12] = '\0';
idl_fileOutPrintf(idl_fileCur(),
"REGISTER_STREAM_TOPIC_TRAITS(%s)\n",
sampleType);
}
os_free(sampleType);
}
return idl_explore;
}
/* Return the scoped type name where for the user types,
scopes are separated by "_" chracters.
*/
c_char *
idl_scopedSplTypeName (
const idl_typeSpec typeSpec)
{
char scopedTypeName[256];
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeSpecType(typeSpec) == idl_tseq) {
/* Sequences map to c_sequence */
os_strncpy (scopedTypeName, "c_sequence", sizeof(scopedTypeName));
/* QAC EXPECT 3416; No unexpected side effects here */
} else if (idl_typeSpecType(typeSpec) == idl_tbasic) {
/* For basic types take the corresponding type name supported by the splice database */
/* QAC EXPECT 3416; No unexpected side effects here */
if (idl_typeBasicType(idl_typeBasic(typeSpec)) == idl_string) {
/* in case of bounded string the type name must become c_string */
/* type name is of form "C_STRING<xx>" */
os_strncpy (scopedTypeName, "c_string", sizeof(scopedTypeName));
} else {
os_strncpy (scopedTypeName, idl_typeSpecName(idl_typeSpec(typeSpec)), sizeof(scopedTypeName));
}
} else if (idl_typeSpecType(typeSpec) == idl_tstruct ||
idl_typeSpecType(typeSpec) == idl_tunion) {
snprintf (scopedTypeName, (size_t)sizeof(scopedTypeName), "struct _%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
} else if (idl_typeSpecType(typeSpec) == idl_tenum) {
snprintf (scopedTypeName, (size_t)sizeof(scopedTypeName), "enum _%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
} else {
snprintf (scopedTypeName, (size_t)sizeof(scopedTypeName), "_%s",
idl_scopeStack (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(idl_typeSpec(typeSpec))));
}
return os_strdup(scopedTypeName);
}
/* Return the standalone C specific type identifier for the
specified type specification
*/
c_char *
idl_sacTypeFromTypeSpec (
const idl_typeSpec typeSpec)
{
c_char *typeName;
/* 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:
typeName = os_strdup("DDS_short");
break;
case idl_ushort:
typeName = os_strdup("DDS_unsigned_short");
break;
case idl_long:
typeName = os_strdup("DDS_long");
break;
case idl_ulong:
typeName = os_strdup("DDS_unsigned_long");
break;
case idl_longlong:
typeName = os_strdup("DDS_long_long");
break;
case idl_ulonglong:
typeName = os_strdup("DDS_unsigned_long_long");
break;
case idl_float:
typeName = os_strdup("DDS_float");
break;
case idl_double:
typeName = os_strdup("DDS_double");
break;
case idl_char:
typeName = os_strdup("DDS_char");
break;
case idl_string:
typeName = os_strdup("DDS_string");
break;
case idl_boolean:
typeName = os_strdup("DDS_boolean");
break;
case idl_octet:
typeName = os_strdup("DDS_octet");
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) {
/* sequence does not have an identification */
typeName = os_strdup ("");
printf ("idl_sacTypeFromTypeSpec: Unexpected sequence type handled\n");
} else if (idl_typeSpecType(typeSpec) == idl_tarray) {
typeName = os_strdup ("");
printf ("idl_sacTypeFromTypeSpec: Unexpected array type handled\n");
} 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_scopeStackC (
idl_typeUserScope(idl_typeUser(typeSpec)),
"_",
idl_typeSpecName(typeSpec));
}
return typeName;
/* QAC EXPECT 5101; The switch statement is simple, therefor the total complexity is low */
}
/* 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 */
}
