void jvmcodegen::gen_variable(const ast::node_ptr &node)
{
auto var = ast::to_variable(node);
auto sym = m_stack.top()->get(var->name);
if (sym.c_type() == types::integer) {
m_out << fmt::sprintf("iload %d\n", sym.local);
} else if (sym.c_type() == types::string) {
m_out << fmt::sprintf("aload %d\n", sym.local);
}
// TODO: string, booleans, etc...
}
c_bool
__sensor_msgs_msg_dds__CompressedImage___copyIn(
c_base base,
struct ::sensor_msgs::msg::dds_::CompressedImage_ *from,
struct _sensor_msgs_msg_dds__CompressedImage_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
if(result){
extern c_bool __std_msgs_msg_dds__Header___copyIn(c_base, ::std_msgs::msg::dds_::Header_ *, _std_msgs_msg_dds__Header_ *);
result = __std_msgs_msg_dds__Header___copyIn(base, &from->header_, &to->header_);
}
#ifdef OSPL_BOUNDS_CHECK
if(from->format_){
to->format_ = c_stringNew(base, from->format_);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'sensor_msgs::msg::dds_::CompressedImage_.format_' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->format_ = c_stringNew(base, from->format_);
#endif
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 774 */
static c_type type0 = NULL;
c_type subtype0;
c_long length0;
c_octet *dest0;
::sensor_msgs::msg::dds_::CompressedImage_::_data__seq *src = &from->data_;
if (type0 == NULL) {
subtype0 = c_type(c_metaResolve (c_metaObject(base), "c_octet"));
type0 = c_metaSequenceTypeNew(c_metaObject(base),"C_SEQUENCE<c_octet>",subtype0,0);
c_free(subtype0);
}
length0 = (c_long)(*src).length();
#ifdef OSPL_BOUNDS_CHECK
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#else
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#endif
}
return result;
}
const c_char*
cmx_participantRegisterType(
const c_char* participant,
const c_char* type)
{
sd_serializer serializer;
sd_serializedData meta_data;
cmx_entityKernelArg kernelArg;
c_type topicType;
cmx_entity ce;
const c_char* result;
const c_char* msg;
ce = cmx_entityClaim(participant);
if(ce != NULL){
kernelArg = cmx_entityKernelArg(os_malloc(C_SIZEOF(cmx_entityKernelArg)));
if (u_observableAction(u_observable(ce->uentity),
cmx_entityKernelAction,
(c_voidp)kernelArg) == U_RESULT_OK)
{
serializer = sd_serializerXMLMetadataNew(c_getBase(c_object(kernelArg->kernel)));
if(serializer != NULL){
meta_data = sd_serializerFromString(serializer, type);
if (meta_data != NULL) {
topicType = c_type(sd_serializerDeserialize(serializer, meta_data));
if (topicType == NULL) {
msg = sd_serializerLastValidationMessage(serializer);
OS_REPORT(OS_ERROR,
CM_XML_CONTEXT, 0,
"Data type could not be registered, "
"because it is not valid: %s",
msg);
result = CMX_RESULT_FAILED;
} else {
result = CMX_RESULT_OK;
}
sd_serializedDataFree(meta_data);
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Construction of serialized data failed.");
result = CMX_RESULT_FAILED;
}
sd_serializerFree(serializer);
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Serializer could not be initialized");
result = CMX_RESULT_FAILED;
}
} else {
OS_REPORT(OS_ERROR, CM_XML_CONTEXT, 0, "Kernel object could not be retrieved");
result = CMX_RESULT_FAILED;
}
os_free(kernelArg);
cmx_entityRelease(ce);
} else {
result = CMX_RESULT_FAILED;
}
return result;
}
static c_type
createKeyType(
const c_char *name,
c_array keyList)
{
c_base base;
c_type foundType;
c_char *typeName;
c_char keyName[16];
c_long i, length, sres;
c_array members;
c_metaObject o;
c_field field;
if (keyList == NULL) {
return NULL;
}
base = c_getBase(keyList);
length = c_arraySize(keyList);
if (length == 0) {
return NULL;
}
o = c_metaDefine(c_metaObject(base),M_STRUCTURE);
members = c_arrayNew(c_member_t(base),length);
for (i=0;i<length;i++) {
field = keyList[i];
assert(field != NULL);
members[i] = (c_voidp)c_metaDefine(c_metaObject(base),M_MEMBER);
sprintf(keyName,"field%d",i);
c_specifier(members[i])->name = c_stringNew(base,keyName);
c_specifier(members[i])->type = c_keep(c_fieldType(field));
}
c_structure(o)->members = members;
c_metaObject(o)->definedIn = c_metaObject(base);
c_metaFinalize(o);
#define KEY_NAME "<Key>"
#define KEY_FORMAT "%s<Key>"
if (name != NULL) {
length = sizeof(KEY_NAME) + strlen(name);
typeName = os_malloc(length);
sres = snprintf(typeName,length,KEY_FORMAT,name);
assert(sres == (length-1));
} else {
assert(FALSE);
length = 100;
typeName = os_malloc(length);
os_sprintf(typeName,PA_ADDRFMT KEY_NAME,(c_address)o);
}
#undef KEY_NAME
#undef KEY_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),typeName,o));
c_free(o);
os_free(typeName);
return foundType;
}
os_boolean
idl_stacDefCanStacBeAppliedToMember(
c_type memberType)
{
os_boolean stacCanBeApplied = OS_FALSE;
c_type dereffedType;
dereffedType = c_typeActualType(c_type(idl_stacDefResolveTypeDef(c_baseObject(memberType))));
if(c_baseObject(dereffedType)->kind == M_COLLECTION)
{
/* Can be a string or an array or a sequence */
if(c_collectionType(dereffedType)->kind == OSPL_C_STRING)
{
if((c_collectionType(dereffedType)->maxSize != 0))
{
/* The string is bounded, stac can be applied */
stacCanBeApplied = OS_TRUE;
}
}
else if(c_collectionType(dereffedType)->kind == OSPL_C_ARRAY)
{
/* bounded string embedded within arrays are allowed, recurse deeper */
stacCanBeApplied = idl_stacDefCanStacBeAppliedToMember(c_collectionType(dereffedType)->subType);
} /* else let memberIsStacOk remain false */
}
return stacCanBeApplied;
}
void
q_dispose(
q_expr expr)
{
c_type t;
if (expr == NULL) return;
switch (expr->kind) {
case T_ID:
case T_STR:
os_free(expr->info.string);
break;
case T_TYP:
break;
case T_FNC:
if (expr->info.function->tag == Q_EXPR_CALLBACK) {
/* The first parameter is not of type q_expr but is of type c_type. */
/* It specifies the result type of the callback function. */
t = c_type(q_getTyp(q_swapPar(expr,0,NULL)));
c_free(t);
q_swapPar(expr,1,NULL);
q_dispose((q_expr)q_swapPar(expr,2,NULL));
}
q_listDispose(expr->info.function->params);
os_free(expr->info.function);
break;
default:
break;
}
if(expr->text) os_free(expr->text);
os_free(expr);
}
static void
extractReferences(
c_type type,
c_object o,
c_voidp data)
{
switch (c_baseObject(type)->kind) {
case M_STRUCTURE:
case M_EXCEPTION:
extractStructReferences(c_structure(type),o,data);
break;
case M_CLASS:
if (c_class(type)->extends != NULL) {
extractReferences(c_type(c_class(type)->extends),o,data);
}
case M_INTERFACE:
extractInterfaceReferences(c_interface(type),o,data);
break;
case M_UNION:
break;
default:
break;
}
}
c_object
c_checkType (
c_object o,
const c_char *name)
{
c_type type;
c_string str;
c_bool found = FALSE;
c_bool stop = FALSE;
if (o == NULL) {
return NULL;
}
c_assertValidDatabaseObject(o);
assert(c_refCount(o) > 0);
assert(name != NULL);
type = c__getType(o);
while (!found && !stop) {
str = c_metaObject(type)->name;
if (str == NULL) {
found = TRUE; /** assume TRUE **/
} else if (strcmp(str,name) != 0) {
switch (c_baseObject(type)->kind) {
case M_CLASS:
type = c_type(c_class(type)->extends);
if (type == NULL) {
if ((strcmp(str,"c_base") == 0) && (strcmp(name,"c_module") == 0)) {
found = TRUE;
}
stop = TRUE;
}
break;
case M_TYPEDEF:
type = c_typeDef(type)->alias;
if (type == NULL) {
stop = TRUE;
}
break;
default:
stop = TRUE;
}
} else {
found = TRUE;
}
}
if (!found) {
#ifndef NDEBUG
if(o != NULL){
str = c_metaObject(c__getType(o))->name;
OS_REPORT_2(OS_ERROR, "Database", 0,
"Type mismatch: object type is %s but %s was expected\n",
str,name);
}
#endif
return NULL;
}
return o;
}
static c_type
createInstanceType(
c_type messageType,
d_topicInfo topicInfo)
{
c_type instanceType, baseType, foundType;
c_metaObject o;
c_char *name;
c_long length,sres;
c_base base;
base = c_getBase(messageType);
baseType = c_resolve(base,"durabilityModule2::d_instanceTemplate");
assert(baseType != NULL);
instanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
c_class(instanceType)->extends = c_class(baseType);
foundType = createTopicKeyType(messageType, topicInfo->keyExpr);
if ( foundType != NULL) {
o = c_metaDeclare(c_metaObject(instanceType),"key",M_ATTRIBUTE);
c_property(o)->type = foundType;
c_free(o);
}
c_metaObject(instanceType)->definedIn = c_keep(base);
c_metaFinalize(c_metaObject(instanceType));
#define INSTANCE_NAME "d_instance<d_sample<>>"
#define INSTANCE_FORMAT "d_instance<d_sample<%s>>"
length = sizeof(INSTANCE_NAME) + strlen(topicInfo->name);
name = os_malloc(length);
sres = snprintf(name,length,INSTANCE_FORMAT,topicInfo->name);
assert(sres == (length-1));
#undef INSTANCE_NAME
#undef INSTANCE_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(instanceType)));
os_free(name);
c_free(instanceType);
return foundType;
}
static c_type
createSampleType(
c_type messageType,
const c_char* topicName)
{
c_base base;
c_type sampleType, baseType, foundType, found;
c_metaObject o;
c_char *name;
c_long length,sres;
base = c_getBase(messageType);
baseType = c_resolve(base, "durabilityModule2::d_sample");
assert(baseType != NULL);
sampleType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
c_class(sampleType)->extends = c_class(baseType);
o = c_metaDefine(c_metaObject(sampleType),M_ATTRIBUTE);
c_property(o)->type = c_keep(messageType);
found = c_type(c_metaBind(c_metaObject(sampleType),"message",o));
c_free(o);
c_free(found);
c_metaObject(sampleType)->definedIn = c_keep(base);
c_metaFinalize(c_metaObject(sampleType));
#define SAMPLE_NAME "d_sample<>"
#define SAMPLE_FORMAT "d_sample<%s>"
/* Create a name and bind type to name */
/* The sizeof contains \0 */
length = sizeof(SAMPLE_NAME) + strlen(topicName);
name = os_malloc(length);
sres = snprintf(name,length,SAMPLE_FORMAT,topicName);
assert(sres == (length-1));
#undef SAMPLE_NAME
#undef SAMPLE_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(sampleType)));
os_free(name);
c_free(sampleType);
return foundType;
}
static c_type
messageTypeNew(
c_base base,
const c_char *typeName)
{
c_metaObject o;
c_type baseType,dataType,type, foundType;
c_char *name;
c_long length, sres;
if (base == NULL) {
return NULL;
}
dataType = c_resolve(base,typeName);
if (dataType == NULL) {
return NULL;
}
baseType = c_resolve(base, "kernelModule::v_message");
assert(baseType != NULL);
type = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
c_class(type)->extends = c_keep(c_class(baseType));
o = c_metaDeclare(c_metaObject(type),
USERDATA_FIELD_NAME,
M_ATTRIBUTE);
c_property(o)->type = dataType;
c_free(o);
c_metaObject(type)->definedIn = c_keep(base);
c_metaFinalize(c_metaObject(type));
#define MESSAGE_FORMAT "v_message<%s>"
#define MESSAGE_NAME "v_message<>"
length = sizeof(MESSAGE_NAME) + strlen(typeName);
name = os_malloc(length);
sres = snprintf(name,length,MESSAGE_FORMAT,typeName);
assert(sres == (length-1));
#undef MESSAGE_FORMAT
#undef MESSAGE_NAME
foundType = c_type(c_metaBind(c_metaObject(base),name,c_metaObject(type)));
os_free(name);
c_free(type);
return foundType;
}
static c_bool
walkProperty(
c_metaObject object,
c_metaWalkActionArg actionArg)
{
toolActionData actionData = (toolActionData)actionArg;
c_object o;
c_voidp addr;
o = c_iterObject(actionData->stack, 0);
if (c_baseObjectKind(object) == M_ATTRIBUTE) {
addr = C_DISPLACE(o, (c_address)c_property(object)->offset);
if (c_typeIsRef(c_property(object)->type)) {
addr = *(c_voidp *)addr;
if (c_baseObjectKind(c_property(object)->type) == M_COLLECTION) {
if (addr) {
if (c_iterContains(actionData->stack, addr)) {
printf("Ignore cyclic reference 0x"PA_ADDRFMT"\n",
(os_address)addr);
} else {
OBJECT_PUSH(actionData, addr);
iprintf("%s ",_METANAME(object));
printType(c_property(object)->type, actionData);
OBJECT_POP(actionData);
}
} else {
iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr);
}
} else {
iprintf(" %s <0x"PA_ADDRFMT">", _METANAME(object), (os_address)addr);
if (addr) {
/* Section for code to print additional type specific info. */
if (c_property(object)->type == v_topic_t) {
printf(" /* topic name is: %s */", v_topicName(addr));
}
if (c_property(object)->type == v_partition_t) {
printf(" /* Partition: %s */", v_partitionName(addr));
}
if (c_property(object)->type == c_type_t(c_getBase(object))) {
printf(" /* Type: %s */", _METANAME(c_type(addr)));
}
}
}
printf("\n");
} else {
OBJECT_PUSH(actionData, addr);
iprintf("%s ",_METANAME(object));
printType(c_property(object)->type, actionData);
printf("\n");
OBJECT_POP(actionData);
}
}
return TRUE;
}
c_bool
__std_msgs_msg_dds__UInt64MultiArray___copyIn(
c_base base,
struct ::std_msgs::msg::dds_::UInt64MultiArray_ *from,
struct _std_msgs_msg_dds__UInt64MultiArray_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
if(result){
extern c_bool __std_msgs_msg_dds__MultiArrayLayout___copyIn(c_base, ::std_msgs::msg::dds_::MultiArrayLayout_ *, _std_msgs_msg_dds__MultiArrayLayout_ *);
result = __std_msgs_msg_dds__MultiArrayLayout___copyIn(base, &from->layout_, &to->layout_);
}
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 774 */
static c_type type0 = NULL;
c_type subtype0;
c_long length0;
c_ulonglong *dest0;
::std_msgs::msg::dds_::UInt64MultiArray_::_data__seq *src = &from->data_;
if (type0 == NULL) {
subtype0 = c_type(c_metaResolve (c_metaObject(base), "c_ulonglong"));
type0 = c_metaSequenceTypeNew(c_metaObject(base),"C_SEQUENCE<c_ulonglong>",subtype0,0);
c_free(subtype0);
}
length0 = (c_long)(*src).length();
#ifdef OSPL_BOUNDS_CHECK
dest0 = (c_ulonglong *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_ulonglong *buf0;
buf0 = (c_ulonglong *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#else
dest0 = (c_ulonglong *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_ulonglong *buf0;
buf0 = (c_ulonglong *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->data_ = (c_sequence)dest0;
#endif
}
return result;
}
void jvmcodegen::gen_assign_stmt(const ast::node_ptr &node)
{
auto assign = ast::to_assign_stmt(node);
auto identifier = ast::to_variable(assign->lvalue);
auto sym = m_stack.top()->get(identifier->name);
// escopo global?
if (m_stack.top()->id <= 0) {
} else {
gen_node(assign->rvalue);
switch (sym.c_type()) {
case types::integer:
m_out << fmt::sprintf("istore %d\n", sym.local);
break;
case types::string:
m_out << fmt::sprintf("astore %d\n", sym.local);
break;
default:
throw jvmcodegen_error(
fmt::sprintf("Tipo de dado nao suportado para atribuicao %d",
sym.c_type()));
}
}
}
static void
printStructure(
c_structure _this,
toolActionData actionData)
{
c_object o;
c_object object;
c_long i, size;
c_member member;
o = c_iterObject(actionData->stack, 0);
if (o) {
if (c_iterLength(actionData->stack) == 1) {
printf("%s ", _METANAME(_this));
} else {
}
printf("{\n");
size = c_structureMemberCount(_this);
for (i=0; i<size; i++) {
member = c_structureMember(_this, i);
object = C_DISPLACE(o, (c_address)member->offset);
if (c_typeIsRef(c_memberType(member))) {
iprintf(" %s <0x"PA_ADDRFMT">\n",
c_specifierName(member),
*(os_address *)object);
} else {
OBJECT_PUSH(actionData, object);
iprintf("%s ",c_specifierName(member));
printType(c_memberType(member), actionData);
printf("\n");
OBJECT_POP(actionData);
}
}
if (c_iterLength(actionData->stack) == 1) {
iprintf("};");
} else {
iprintf("} %s;", _METANAME(_this));
}
if (c_type(_this) == v_handle_t) {
v_object vo;
v_handleClaim(*(v_handle *)o,&vo);
v_handleRelease(*(v_handle *)o);
printf(" /* Handle's object: <0x"PA_ADDRFMT"> */", (os_address)vo);
}
}
}
c_bool
__rcl_interfaces_srv_dds__GetParameterTypes_Response___copyIn(
c_base base,
struct ::rcl_interfaces::srv::dds_::GetParameterTypes_Response_ *from,
struct _rcl_interfaces_srv_dds__GetParameterTypes_Response_ *to)
{
c_bool result = OS_C_TRUE;
(void) base;
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 774 */
static c_type type0 = NULL;
c_type subtype0;
c_long length0;
c_octet *dest0;
::rcl_interfaces::srv::dds_::GetParameterTypes_Response_::_types__seq *src = &from->types_;
if (type0 == NULL) {
subtype0 = c_type(c_metaResolve (c_metaObject(base), "c_octet"));
type0 = c_metaSequenceTypeNew(c_metaObject(base),"C_SEQUENCE<c_octet>",subtype0,0);
c_free(subtype0);
}
length0 = (c_long)(*src).length();
#ifdef OSPL_BOUNDS_CHECK
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->types_ = (c_sequence)dest0;
#else
dest0 = (c_octet *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_octet *buf0;
buf0 = (c_octet *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->types_ = (c_sequence)dest0;
#endif
}
return result;
}
v_object
v_new(
v_kernel kernel,
c_type type)
{
v_object o;
c_type t;
c_long i;
assert(C_TYPECHECK(kernel,v_kernel));
assert(C_TYPECHECK(type,c_type));
if (type == NULL) {
return NULL;
}
o = c_new(type);
if (o) {
o->kernel = kernel;
t = type;
while (t != NULL) {
for (i=0;i<K_TYPECOUNT;i++) {
if (t == kernel->type[i]) {
o->kind = i;
return o;
}
}
if (c_baseObject(t)->kind == M_CLASS) {
t = c_type(c_class(t)->extends);
} else {
t = NULL;
}
}
o->kind = K_OBJECT;
} else {
OS_REPORT(OS_ERROR,
"v_new",0,
"Failed to create kernel object.");
assert(FALSE);
}
return o;
}
void jvmcodegen::gen_call(const ast::node_ptr &node)
{
auto call = ast::to_call(node);
auto sym = m_stack.top()->get(call->name);
if (!call->param_list.empty()) {
size_t i = call->param_list.size() - 1;
while (true) {
gen_node(call->param_list[i]);
if (i == 0)
break;
i--;
}
}
m_out << fmt::sprintf("invokestatic ptb/%s\n", sym.signature);
if (call->is_stmt) {
// se a função retornar alguma coisa, descarta o resultado
if (sym.c_type() != types::voidt) {
m_out << fmt::sprintf("pop\n");
}
}
}
d_storeResult
d_groupInfoDataInject(
d_groupInfo _this,
const d_store store,
d_group group)
{
d_storeResult result;
struct d_instanceInjectArg inject;
c_type mmfMessageType;
c_char* typeName;
if(_this && group){
inject.vgroup = d_groupGetKernelGroup(group);
mmfMessageType = d_topicInfoGetMessageType(_this->topic);
typeName = c_metaScopedName(c_metaObject(mmfMessageType));
inject.messageType = c_type(c_metaResolveType(
c_metaObject(c_getBase(inject.vgroup)), typeName));
if(inject.messageType){
inject.result = D_STORE_RESULT_OK;
c_tableWalk(_this->instances, d_instanceInject, &inject);
c_free(inject.messageType);
result = inject.result;
} else {
result = D_STORE_RESULT_PRECONDITION_NOT_MET;
}
c_free(inject.vgroup);
c_free(mmfMessageType);
os_free(typeName);
} else {
result = D_STORE_RESULT_ILL_PARAM;
}
return result;
}
static c_type
cloneType(
c_base src,
c_base dst,
c_type object)
{
sd_serializer serializer, deserializer;
sd_serializedData data;
c_char* xmlData;
c_type result;
result = NULL;
serializer = sd_serializerXMLTypeinfoNew(src, FALSE);
deserializer = sd_serializerXMLTypeinfoNew(dst, FALSE);
if(serializer && deserializer){
data = sd_serializerSerialize(serializer, object);
if(data){
xmlData = sd_serializerToString(serializer, data);
sd_serializedDataFree(data);
if(xmlData){
data = sd_serializerFromString(deserializer, xmlData);
if(data){
result = c_type(sd_serializerDeserializeValidated(
deserializer, data));
sd_serializedDataFree(data);
}
os_free(xmlData);
}
}
sd_serializerFree(serializer);
sd_serializerFree(deserializer);
}
return result;
}
c_unionCase
c_unionCaseNew (
c_metaObject scope,
const c_char *name,
c_type type,
c_iter labels)
{
c_unionCase o;
c_ulong nrOfLabels;
c_type subType;
nrOfLabels = c_iterLength(labels);
o = c_unionCase(c_metaDefine(scope,M_UNIONCASE));
subType = c_type(c_metaResolve(scope,"c_literal"));
o->labels = c_arrayNew(subType,nrOfLabels);
c_free(subType);
c_iterArray(labels,o->labels);
c_specifier(o)->name = c_stringNew(c__getBase(scope),name);
/* Do not keep type as usage expects transferral of refcount.
* If changed then odlpp and idlpp must be adapted accordingly.
*/
c_specifier(o)->type = type;
return o;
}
static c_bool
display_orc (
c_object o,
c_voidp args
)
{
refLeaf ord = (refLeaf)o;
monitor_orc trace = (monitor_orc)args;
regmatch_t match[1];
if (ord->tr == nullType) {
if (trace->delta) {
if (abs(ord->rc - ord->prc) >= trace->extendCountLimit) {
printf ("%6d <undefined>\r\n", (ord->rc - ord->prc));
}
} else {
if (ord->rc >= trace->extendCountLimit) {
printf ("%6d <undefined>\r\n", ord->rc);
}
}
} else {
switch (c_baseObject(ord->tr)->kind) {
case M_COLLECTION:
switch (c_collectionType(ord->tr)->kind) {
case C_UNDEFINED:
case C_LIST:
case C_ARRAY:
case C_BAG:
case C_SET:
case C_MAP:
case C_DICTIONARY:
case C_SEQUENCE:
case C_STRING:
case C_WSTRING:
case C_QUERY:
case C_SCOPE:
case C_COUNT:
if (trace->delta) {
if (abs(ord->rc - ord->prc) >= trace->extendCountLimit) {
if (trace->filterExpression) {
if (regexec (&trace->expression, c_metaObject(ord->tr)->name, 1, match, 0) == REG_NOMATCH) {
break;
}
}
printf ("%6d (%6d) %6d %10d %-15s %-15s ",
ord->rc - ord->prc,
ord->rc,
(int)c_type(ord->tr)->size,
(int)(c_type(ord->tr)->size * (ord->rc - ord->prc)),
baseKind[c_baseObject(ord->tr)->kind],
collectionKind[c_collectionType(ord->tr)->kind]);
printScope (c_metaObject(ord->tr)->definedIn);
printf ("::%s\r\n", c_metaObject(ord->tr)->name);
trace->totalSizeCount += c_type(ord->tr)->size * (ord->rc - ord->prc);
trace->totalObjectCount += ord->rc - ord->prc;
}
} else {
if (ord->rc >= trace->extendCountLimit) {
if (trace->filterExpression) {
if (regexec (&trace->expression, c_metaObject(ord->tr)->name, 1, match, 0) == REG_NOMATCH) {
break;
}
}
printf ("%6d %6d %10d %-15s %-15s ",
ord->rc,
(int)c_type(ord->tr)->size,
(int)(c_type(ord->tr)->size * ord->rc),
baseKind[c_baseObject(ord->tr)->kind],
collectionKind[c_collectionType(ord->tr)->kind]);
printScope (c_metaObject(ord->tr)->definedIn);
printf ("::%s\r\n", c_metaObject(ord->tr)->name);
trace->totalSizeCount += c_type(ord->tr)->size * ord->rc;
trace->totalObjectCount += ord->rc;
}
}
break;
}
break;
case M_PRIMITIVE:
case M_TYPEDEF:
case M_ENUMERATION:
case M_UNION:
case M_STRUCTURE:
case M_INTERFACE:
case M_CLASS:
case M_EXCEPTION:
case M_EXTENT:
case M_EXTENTSYNC:
if (trace->delta) {
if (abs(ord->rc - ord->prc) >= trace->extendCountLimit) {
if (trace->filterExpression) {
if (regexec (&trace->expression, c_metaObject(ord->tr)->name, 1, match, 0) == REG_NOMATCH) {
break;
}
}
printf ("%6d (%6d) %6d %10d %-15s ",
ord->rc - ord->prc,
ord->rc,
(int)c_type(ord->tr)->size,
(int)(c_type(ord->tr)->size * (ord->rc - ord->prc)),
baseKind[c_baseObject(ord->tr)->kind]);
printf (" ");
printScope (c_metaObject(ord->tr)->definedIn);
printf ("::%s\r\n", c_metaObject(ord->tr)->name);
trace->totalSizeCount += c_type(ord->tr)->size * (ord->rc - ord->prc);
trace->totalObjectCount += ord->rc - ord->prc;
}
} else {
if (ord->rc >= trace->extendCountLimit) {
if (trace->filterExpression) {
if (regexec (&trace->expression, c_metaObject(ord->tr)->name, 1, match, 0) == REG_NOMATCH) {
break;
}
}
printf ("%6d %6d %10d %-15s ",
ord->rc,
(int)c_type(ord->tr)->size,
(int)(c_type(ord->tr)->size * ord->rc),
baseKind[c_baseObject(ord->tr)->kind]);
printf (" ");
printScope (c_metaObject(ord->tr)->definedIn);
printf ("::%s\r\n", c_metaObject(ord->tr)->name);
trace->totalSizeCount += c_type(ord->tr)->size * ord->rc;
trace->totalObjectCount += ord->rc;
}
}
break;
case M_UNDEFINED:
case M_ATTRIBUTE:
case M_CONSTANT:
case M_CONSTOPERAND:
case M_EXPRESSION:
case M_LITERAL:
case M_MEMBER:
case M_OPERATION:
case M_PARAMETER:
case M_RELATION:
case M_BASE:
case M_UNIONCASE:
case M_COUNT:
case M_MODULE:
break;
}
}
ord->prc = ord->rc;
ord->rc = 0;
return TRUE;
}
/**************************************************************
* constructor/destructor
**************************************************************/
v_serviceState
v_serviceStateNew(
v_kernel k,
const c_char *name,
const c_char *extStateName)
{
v_serviceState s;
c_type type;
assert(C_TYPECHECK(k, v_kernel));
if (extStateName == NULL) {
s = v_serviceState(v_objectNew(k, K_SERVICESTATE));
} else {
type = c_resolve(c_getBase(c_object(k)), extStateName);
if (type != NULL) {
#if !defined NDEBUG
c_type t = type;
c_bool correctType;
correctType = FALSE;
while ((correctType == FALSE) &&
(t != NULL) &&
(c_baseObject(t)->kind == M_CLASS)) {
if (strcmp(c_metaObject(t)->name, "v_serviceState") == 0) {
correctType = TRUE;
} else {
t = c_type(c_class(t)->extends);
}
}
if ((correctType == FALSE) && (t != NULL)) {
OS_REPORT(OS_FATAL, "v_serviceState", 0, "Given type not a class");
assert(0);
} else {
if (correctType == FALSE) {
OS_REPORT(OS_FATAL, "v_serviceState",
0, "Given type does not extend v_serviceState");
assert(0);
}
}
#endif
s = v_serviceState(c_new(type));
if (s) {
v_objectKind(s) = K_SERVICESTATE;
v_object(s)->kernel = k;
} else {
OS_REPORT(OS_ERROR,
"v_serviceStateNew",0,
"Failed to allocate v_serviceState object.");
assert(FALSE);
}
} else {
s = NULL;
}
}
if (s != NULL) {
v_serviceStateInit(s, name);
}
return s;
}
static void
c_deepwalkUnion(
c_union v_union,
c_object *objectPtr,
c_deepwalkFunc action,
void *actionArg)
{
c_type switchType;
c_type caseType;
c_unionCase deflt;
c_unionCase activeCase;
c_unionCase currentCase;
c_object unionData;
c_value switchValue;
c_literal label;
int i,j, nCases, nLabels;
c_long dataOffset;
/* action for the union itself */
/* No action, but separate actions for the switch and the data */
/* action(c_type(v_union), objectPtr, actionArg); */
/* action for the switch */
c_deepwalkType(v_union->switchType, objectPtr,
action, actionArg);
switchType = c_typeActualType(v_union->switchType);
/* Determine value of the switch field */
switch (c_baseObject(switchType)->kind) {
case M_PRIMITIVE:
switch (c_primitive(switchType)->kind) {
#define __CASE__(prim, type) \
case prim: switchValue = type##Value(*((type *)*objectPtr)); break;
__CASE__(P_BOOLEAN,c_bool)
__CASE__(P_CHAR,c_char)
__CASE__(P_SHORT,c_short)
__CASE__(P_USHORT,c_ushort)
__CASE__(P_LONG,c_long)
__CASE__(P_ULONG,c_ulong)
__CASE__(P_LONGLONG,c_longlong)
__CASE__(P_ULONGLONG,c_ulonglong)
#undef __CASE__
default:
switchValue = c_undefinedValue();
assert(FALSE);
break;
}
break;
case M_ENUMERATION:
switchValue = c_longValue(*(c_long *)*objectPtr);
break;
default:
switchValue = c_undefinedValue();
assert(FALSE);
break;
}
/* Determine the label corresponding to this field */
activeCase = NULL;
deflt = NULL;
nCases = c_arraySize(v_union->cases);
for (i=0; (i<nCases) && !activeCase; i++) {
currentCase = c_unionCase(v_union->cases[i]);
nLabels = c_arraySize(currentCase->labels);
if (nLabels > 0) {
for (j=0; (j<nLabels) && !activeCase; j++) {
label = c_literal(currentCase->labels[j]);
if (c_valueCompare(switchValue, label->value) == C_EQ) {
activeCase = currentCase;
}
}
} else {
deflt = currentCase;
}
}
if (!activeCase) {
activeCase = deflt;
}
assert(activeCase);
if (activeCase) {
caseType = c_specifier(activeCase)->type;
if (c_type(v_union)->alignment >= v_union->switchType->size) {
dataOffset = c_type(v_union)->alignment;
} else {
dataOffset = v_union->switchType->size;
}
unionData = C_DISPLACE(*objectPtr, (c_address)dataOffset);
c_deepwalkType(caseType, &unionData, action, actionArg);
}
}
static c_type
createInstanceType (
v_topic topic,
c_char *keyExpr,
c_array *keyListRef)
{
c_metaObject o;
c_type instanceType, baseType, foundType;
c_type sampleType, keyType, keyInstanceType;
c_base base;
c_char *name;
os_size_t length;
int sres;
assert(C_TYPECHECK(topic,v_topic));
foundType = NULL;
if (keyExpr) {
keyType = v_topicKeyTypeCreate(topic,keyExpr,keyListRef);
} else {
keyExpr = v_topicKeyExpr(topic);
keyType = v_topicKeyType(topic);
*keyListRef = c_keep(v_topicMessageKeyList(topic));
}
sampleType = sampleTypeNew(topic);
if (sampleType) {
base = c_getBase(topic);
baseType = v_dataReaderInstance_t(base);
instanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
if (instanceType != NULL) {
c_class(instanceType)->extends = c_keep(c_class(baseType));
o = c_metaDeclare(c_metaObject(instanceType),
"sample",M_ATTRIBUTE);
c_property(o)->type = c_keep(sampleType);
c_free(o);
o = c_metaDeclare(c_metaObject(instanceType),
"oldest",M_ATTRIBUTE);
c_property(o)->type = (c_type)c_metaResolveType(c_metaObject(base),
"c_voidp");
assert(c_property(o)->type);
c_free(o);
c_metaFinalize(c_metaObject(instanceType));
#define INSTANCE_NAME "v_indexInstance<v_indexSample<>>"
#define INSTANCE_FORMAT "v_indexInstance<v_indexSample<%s>>"
/* The sizeof contains \0 */
length = sizeof(INSTANCE_NAME) + strlen(v_topicName(topic));
name = os_alloca(length);
sres = snprintf(name,length,INSTANCE_FORMAT,v_topicName(topic));
assert(sres >= 0 && (os_size_t) sres == (length-1));
OS_UNUSED_ARG(sres);
#undef INSTANCE_NAME
#undef INSTANCE_FORMAT
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(instanceType)));
if (foundType == NULL) {
OS_REPORT(OS_ERROR,
"v_index::createInstanceType",V_RESULT_INTERNAL_ERROR,
"Could not create instance type");
}
os_freea(name);
if (keyType != NULL) {
keyInstanceType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
if (keyInstanceType) {
c_class(keyInstanceType)->extends = c_keep(c_class(instanceType));
o = c_metaDeclare(c_metaObject(keyInstanceType),
"key",M_ATTRIBUTE);
c_property(o)->type = c_keep(keyType);
c_free(o);
c_metaFinalize(c_metaObject(keyInstanceType));
#define INSTANCE_NAME "v_indexKeyInstance<v_indexSample<>,>"
#define INSTANCE_FORMAT "v_indexKeyInstance<v_indexSample<%s>,%s>"
/* The sizeof contains \0 */
length = sizeof(INSTANCE_NAME) +
strlen(v_topicName(topic)) +
strlen(keyExpr);
name = os_alloca(length);
sres = snprintf(name,
length,
INSTANCE_FORMAT,
v_topicName(topic),
keyExpr);
assert(sres >= 0 && (os_size_t) sres == (length-1));
OS_UNUSED_ARG(sres);
#undef INSTANCE_NAME
#undef INSTANCE_FORMAT
c_free(foundType); /* Will be overwritten, so free */
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(keyInstanceType)));
if (foundType == NULL) {
OS_REPORT(OS_ERROR,
"v_index::createInstanceType",V_RESULT_INTERNAL_ERROR,
"Could not create key instance type");
}
os_freea(name);
c_free(keyInstanceType);
}
c_free(keyType);
}
c_free(instanceType);
c_free(baseType);
} else {
foundType = baseType; /* transfer refCount to caller */
}
c_free(sampleType);
}
return foundType;
}
static c_type
sampleTypeNew(
v_topic topic)
{
c_metaObject o;
c_type msgType,sampleType,foundType;
c_base base;
c_char *name;
os_size_t length;
int sres;
assert(C_TYPECHECK(topic,v_topic));
assert(topic);
name = NULL;
foundType = NULL;
if (v_topicName(topic) == NULL) {
OS_REPORT(OS_ERROR,
"v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM,
"failed to retreive topic name");
return NULL;
}
base = c_getBase(topic);
if (base == NULL) {
OS_REPORT(OS_ERROR,
"v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM,
"failed to retreive base");
return NULL;
}
msgType = c_keep(v_topicMessageType(topic));
if (msgType == NULL) {
OS_REPORT(OS_ERROR,
"v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM,
"failed to retreive topic message type");
return NULL;
}
sampleType = c_type(c_metaDefine(c_metaObject(base),M_CLASS));
if (sampleType) {
c_class(sampleType)->extends = v_dataReaderSample_t(base);
o = c_metaDeclare(c_metaObject(sampleType),"message",M_ATTRIBUTE);
if (o) {
c_property(o)->type = c_keep(msgType);
c_metaObject(sampleType)->definedIn = c_keep(base);
c_metaFinalize(c_metaObject(sampleType));
#define SAMPLE_FORMAT "v_indexSample<%s>"
#define SAMPLE_NAME "v_indexSample<>"
/* sizeof contains \0 */
length = sizeof(SAMPLE_NAME) + strlen(v_topicName(topic));
name = os_malloc(length);
sres = snprintf(name,length,SAMPLE_FORMAT,v_topicName(topic));
assert(sres >= 0 && (os_size_t) sres == (length-1));
OS_UNUSED_ARG(sres);
#undef SAMPLE_FORMAT
#undef SAMPLE_NAME
foundType = c_type(c_metaBind(c_metaObject(base),
name,
c_metaObject(sampleType)));
c_free(o);
} else {
foundType = NULL;
}
c_free(sampleType);
} else {
OS_REPORT(OS_ERROR,
"v_index::sampleTypeNew failed",V_RESULT_ILL_PARAM,
"failed to retreive topic sample type");
}
os_free(name);
c_free(msgType);
return foundType;
}
binding* operator()(const null_t&) const { return new binding_null(c_type(), sql_type()); }
void
in_messageDeserializerReadUnion(
in_messageDeserializer _this,
c_type type,
c_voidp data)
{
c_union utype = c_union(type);
c_type caseType;
c_type switchType;
c_unionCase deflt;
c_unionCase activeCase;
c_unionCase currentCase;
c_value switchValue;
c_literal label;
c_voidp o;
os_uint32 length;
os_uint32 i;
os_uint32 j;
os_uint32 n;
assert(_this);
assert(type);
assert(data);
/* action for the switch */
switchType = c_typeActualType(utype->switchType);
in_messageDeserializerReadType(_this, switchType, data);
/* Determine value of the switch field */
switch (c_baseObjectKind(switchType))
{
case M_PRIMITIVE:
switch (c_primitiveKind(switchType))
{
#define __CASE__(prim, type) \
case prim: switchValue = type##Value(*((type *)data)); break;
__CASE__(P_BOOLEAN,c_bool)
__CASE__(P_CHAR,c_char)
__CASE__(P_SHORT,c_short)
__CASE__(P_USHORT,c_ushort)
__CASE__(P_LONG,c_long)
__CASE__(P_ULONG,c_ulong)
__CASE__(P_LONGLONG,c_longlong)
__CASE__(P_ULONGLONG,c_ulonglong)
#undef __CASE__
default:
switchValue = c_undefinedValue();
assert(FALSE);
break;
}
break;
case M_ENUMERATION:
switchValue = c_longValue(*(c_long *)data);
break;
default:
switchValue = c_undefinedValue();
assert(FALSE);
break;
}
/* Determine the label corresponding to this field */
activeCase = NULL;
deflt = NULL;
length = c_arraySize(utype->cases);
for (i = 0; (i < length) && !activeCase; i++)
{
currentCase = c_unionCase(utype->cases[i]);
n = c_arraySize(currentCase->labels);
if (n > 0)
{
for (j = 0; (j < n) && !activeCase; j++)
{
label = c_literal(currentCase->labels[j]);
if (c_valueCompare(switchValue, label->value) == C_EQ)
{
activeCase = currentCase;
}
}
} else
{
deflt = currentCase;
}
}
if(!activeCase)
{
activeCase = deflt;
}
assert(activeCase);
if (activeCase)
{
if (c_type(utype)->alignment >= utype->switchType->size)
{
length = c_type(utype)->alignment;
} else
{
length = utype->switchType->size;
}
o = C_DISPLACE(data, (c_address)length);
caseType = c_typeActualType(c_specifierType(activeCase));
in_messageDeserializerReadType(_this, caseType, o);
}
}
/*
* Check if each usage of a char array as a key has a corresponding
* "#pragma cats" declaration.
*/
static c_bool
idl_checkCatsUsage(
c_base base,
const char* filename)
{
char errorBuffer [IDL_MAX_ERRORSIZE];
idl_keyDef keyDef = idl_keyDefDefGet();
c_long keyMapIdx;
idl_keyMap keyMap;
c_type type;
c_structure structure;
c_iter keysList;
os_uint32 keysListSize;
os_uint32 keyIdx;
c_char* keyName;
os_uint32 i;
c_iter keyNameList;
os_uint32 keyNameListSize;
c_structure tmpStructure;
c_specifier sp;
c_type subType;
c_string typeName;
c_type spType;
if (keyDef != NULL) {
/* check all key definition list elements */
for (keyMapIdx = 0; keyMapIdx < c_iterLength(keyDef->keyList); keyMapIdx++) {
keyMap = c_iterObject(keyDef->keyList, keyMapIdx);
/* if a keylist is defined for the type */
if (keyMap->keyList && strlen(keyMap->keyList) > 0) {
/* find meteobject for the type */
type = c_type(c_metaResolveType(keyMap->scope, keyMap->typeName));
if (!type) {
snprintf(errorBuffer, IDL_MAX_ERRORSIZE-1, errorText[idl_UndeclaredIdentifier], keyMap->typeName);
idl_printError(filename, errorBuffer);
return OS_FALSE;
}
/* type can be a typedef. Determine the actual type. */
type = c_typeActualType(type);
/* type should be a structure */
if (c_baseObject(type)->kind != M_STRUCTURE) {
snprintf(errorBuffer, IDL_MAX_ERRORSIZE-1, errorText[idl_IllegalKeyFields]);
idl_printError(filename, errorBuffer);
return OS_FALSE;
}
structure = c_structure(type);
/* for each key in keyList, check if type is a char array */
keysList = c_splitString(keyMap->keyList, ",");
keysListSize = c_iterLength(keysList);
for(keyIdx = 0; keyIdx < keysListSize; keyIdx++)
{
keyName = c_iterTakeFirst(keysList);
/* We might be dealing with a field of a field definition in
* the keylist, so let's split this up
*/
keyNameList = c_splitString(keyName, ".");
keyNameListSize = c_iterLength(keyNameList);
tmpStructure = structure;
for(i = 0; i < keyNameListSize; i++)
{
keyName = c_iterTakeFirst(keyNameList);
/* Now get the actual member defined by the name */
sp = c_specifier(c_metaFindByName(
c_metaObject(tmpStructure),
keyName,
CQ_FIXEDSCOPE | CQ_MEMBER | CQ_CASEINSENSITIVE));
if(sp)
{
spType = c_typeActualType(sp->type);
/* If the member is a structure, we need to
* recurse deeper.
*/
if(c_baseObject(spType)->kind == M_STRUCTURE)
{
tmpStructure = c_structure(spType);
}
/* If the member is a collection then we need to
* ensure it is not a character array, but if it
* is we need to ensure a corresponding CATS pragma
* can be located
*/
else if(c_baseObject(spType)->kind == M_COLLECTION && c_collectionType(spType)->kind == C_ARRAY)
{
subType = c_typeActualType(c_collectionType(spType)->subType);
if(c_baseObject(subType)->kind == M_PRIMITIVE &&
c_primitive(subType)->kind == P_CHAR)
{
typeName = c_metaName(c_metaObject(tmpStructure));
/* check if there is corresponding catsDef */
if (!idl_isCatsDefFor(c_metaObject(tmpStructure)->definedIn,
typeName,
keyName))
{
snprintf(
errorBuffer,
IDL_MAX_ERRORSIZE-1,
errorText[idl_NoCorrespondingCats],
c_metaObject(structure)->name,
keyName);
idl_printError(filename, errorBuffer);
return OS_FALSE;
}
c_free(typeName);
}
}
}
}
}
}
}
}
return OS_TRUE;
}
c_type
idl_stacDefConvertStacApprovedMember(
c_structure structure,
c_type orgMemberType)
{
c_type dereffedOrgType;
c_metaObject o = NULL;
c_type newType;
os_char buffer[1024];
c_metaObject found;
memset(buffer, 0, 1024);
dereffedOrgType = c_typeActualType(c_type(idl_stacDefResolveTypeDef(c_baseObject(orgMemberType))));
if(c_baseObject(dereffedOrgType)->kind == M_COLLECTION)
{
o = c_metaObject(c_metaDefine(c_metaObject(structure), M_COLLECTION));
/* Can be a string or an array or a sequence */
if(c_collectionType(dereffedOrgType)->kind == OSPL_C_STRING)
{
if((c_collectionType(dereffedOrgType)->maxSize != 0))
{
c_collectionType(o)->kind = OSPL_C_ARRAY;
c_collectionType(o)->subType = c_type(c_metaResolve(c_metaObject(structure), "c_char"));
/* increase maxSize with 1 to accomodate the '\0' char found in strings */
c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize + 1;
os_sprintf(
buffer,
"C_ARRAY<%s,%d>",
c_metaObject(c_collectionType(o)->subType)->name,
c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/);
}
else
{
printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but "
"encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) "
"has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n",
c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
}
else if(c_collectionType(dereffedOrgType)->kind == OSPL_C_ARRAY)
{
c_collectionType(o)->kind = OSPL_C_ARRAY;
/* increase maxSize with 1 to accomodate the '\0' char found in strings */
c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize;
c_collectionType(o)->subType = idl_stacDefConvertStacApprovedMember(structure, c_collectionType(dereffedOrgType)->subType);
os_sprintf(
buffer,
"C_ARRAY<%s,%d>",
c_metaObject(c_collectionType(o)->subType)->name,
c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/);
}
else if(c_collectionType(dereffedOrgType)->kind == OSPL_C_SEQUENCE)
{
c_collectionType(o)->kind = OSPL_C_SEQUENCE;
/* increase maxSize with 1 to accomodate the '\0' char found in strings */
c_collectionType(o)->maxSize = c_collectionType(dereffedOrgType)->maxSize;
c_collectionType(o)->subType = idl_stacDefConvertStacApprovedMember(structure, c_collectionType(dereffedOrgType)->subType);
os_sprintf(
buffer,
"C_SEQUENCE<%s,%d>",
c_metaObject(c_collectionType(o)->subType)->name,
c_collectionType(o)->maxSize/*use maxSize of new c_type, must be the same*/);
}
else
{
printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but "
"encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) "
"has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n",
c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
}
else
{
printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but "
"encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) "
"has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n",
c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
if(o)
{
c_metaObject(o)->definedIn = c_metaObject(structure);
c_metaFinalize(o);
found = c_metaBind(c_metaObject(structure), &buffer[0], o);
c_free(o);
newType = c_type(found);
}
else
{
printf("FATAL ERROR | #pragma stac: Trying to apply stac algorithm to listed members of struct %s, but "
"encountered an internal error. The conversion algorithm (idl_stacDefConvertStacApprovedMember) "
"has become out of synch with the verification algorithm (idl_stacDefCanStacBeAppliedToMember).\n",
c_metaScopedName(c_metaObject(structure)));
assert(0);
exit(-2);
}
return newType;
}
