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;
}
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;
}
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;
}
static void
userDataQosPolicyCopyin (
c_base base,
const gapi_userDataQosPolicy *src,
struct v_userDataPolicy *dst)
{
static c_type gapi_userData_type = NULL;
if ( src->value._length > 0 ) {
if (gapi_userData_type == NULL) {
c_type type = c_octet_t(base);
if (type) {
gapi_userData_type =
c_metaArrayTypeNew(c_metaObject(base),
"C_ARRAY<c_octet>",
type,0);
c_free(type);
}
}
if ( gapi_userData_type ) {
dst->value = c_newArray(c_collectionType(gapi_userData_type),
src->value._length);
if ( dst->value ) {
memcpy(dst->value, src->value._buffer, src->value._length);
}
}
} else {
dst->value = NULL;
}
}
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;
}
static c_bool
_cloneReference (
c_type type,
c_voidp data,
c_voidp dest)
{
c_type t = type;
assert(data);
assert(type);
while (c_baseObject(t)->kind == M_TYPEDEF) {
t = c_typeDef(t)->alias;
}
switch (c_baseObject(t)->kind) {
case M_CLASS:
case M_INTERFACE:
c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest);
break;
case M_BASE:
case M_COLLECTION:
if ((c_collectionType(t)->kind == C_ARRAY) &&
(c_collectionType(t)->maxSize != 0)) {
c__cloneReferences(t, data, dest);
} else {
c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest);
}
break;
case M_EXCEPTION:
case M_STRUCTURE:
case M_UNION:
c__cloneReferences(t, data, dest);
break;
case M_EXTENT:
case M_EXTENTSYNC:
c_cloneIn(t, C_REFGET(data, 0), (c_voidp *) dest);
break;
default:
OS_REPORT(OS_ERROR,
"cloneReference",0,
"illegal object detected");
assert(FALSE);
return FALSE;
}
return TRUE;
}
c_collectionType
c_fieldPath_t (
c_base _this)
{
if (_this->baseCache.fieldCache.c_fieldPath_t == NULL) {
_this->baseCache.fieldCache.c_fieldPath_t = c_collectionType(
c_metaArrayTypeNew(c_metaObject(_this),
"C_ARRAY<c_base>",
c_getMetaType(_this,M_BASE),
0));
}
return _this->baseCache.fieldCache.c_fieldPath_t;
}
c_collectionType
c_fieldRefs_t (
c_base _this)
{
if (_this->baseCache.fieldCache.c_fieldRefs_t == NULL) {
_this->baseCache.fieldCache.c_fieldRefs_t = c_collectionType(
c_metaArrayTypeNew(c_metaObject(_this),
"C_ARRAY<c_address>",
c_address_t(_this),
0));
}
return _this->baseCache.fieldCache.c_fieldRefs_t;
}
static void
builtinPartitionQosPolicyCopyin (
c_base base,
const gapi_partitionQosPolicy *src,
struct v_builtinPartitionPolicy *dst)
{
static c_type gapi_partitionQos_type = NULL;
if ( src->name._length > 0 ) {
if (gapi_partitionQos_type == NULL) {
c_type type = c_string_t(base);
if (type) {
gapi_partitionQos_type =
c_metaSequenceTypeNew(c_metaObject(base),
"C_SEQUENCE<c_string>",
type,0);
c_free(type);
}
}
if ( gapi_partitionQos_type ) {
dst->name = c_newSequence(c_collectionType(gapi_partitionQos_type),
src->name._length);
if ( dst->name ) {
gapi_unsigned_long i;
for ( i = 0; i < src->name._length; i++ ) {
if ( src->name._buffer[i] ) {
dst->name[i] = c_stringNew(base, src->name._buffer[i]);
} else {
dst->name[i] = NULL;
}
}
}
}
} else {
dst->name = NULL;
}
}
/* TODO should propagate the result code, might have an out of memory error
* if allocation of the array failed
*/
void
in_messageDeserializerReadArray(
in_messageDeserializer _this,
c_type type,
c_voidp data)
{
in_result result = IN_RESULT_OK;
c_collectionType ctype = c_collectionType(type);
os_uint32 size;
os_uint32 length;
os_uint32 i;
c_voidp array = NULL;
c_object o;
c_collKind typeKind;
c_metaKind subTypeKind;
assert(_this);
assert(in_messageDeserializerIsValid(_this));
assert(type);
assert(data);
/* First determine the length of the array. For IDL array types the length
* is known, but for sequences it is encoded ahead of the elements as an
* unsigned long
*/
typeKind = ctype->kind;
if(typeKind == C_ARRAY)
{
array = data;
length = ctype->maxSize;
assert(array);
} else
{
assert(typeKind == C_SEQUENCE);
/* For a sequence the length is encoded as an unsigned long, which in
* CDR is 4 octets(bytes) in size.
*/
assert(sizeof(os_uint32) == 4);
in_messageDeserializerReadPrim(_this, 4, &length);
/* Verify that the length is equal to or smaller then the maxSize if
* maxSize is bigger then 0
*/
if(ctype->maxSize > 0)
{
array = data;
assert((c_long)length <= ctype->maxSize);
assert(array);
} else
{
if(*(c_voidp *)data)
{
array = *(c_voidp *)data;
} else
{
array = c_arrayNew(type, (c_long)length);
if(length > 0 && !array)
{
result = IN_RESULT_OUT_OF_MEMORY;
}
*(c_voidp *)data = array;
}
}
}
if (length > 0 && result == IN_RESULT_OK)
{
assert(array);
subTypeKind = c_baseObjectKind(c_baseObject(ctype->subType));
if((subTypeKind == M_PRIMITIVE) ||(subTypeKind == M_ENUMERATION))
{
o = array;
/* in_messageDeserializerReadPrimArray(
_this,
ctype->subType->size,
length,
o);*/
} else
{
if (c_typeIsRef(ctype->subType))
{
size = sizeof(c_voidp);
} else
{
size = ctype->subType->size;
}
o = array;
for (i = 0; i < length; i++)
{
in_messageDeserializerReadType(_this, ctype->subType, o);
o = C_DISPLACE(o, size);
}
}
}
}
static c_bool
c__cloneReferences (
c_type type,
c_voidp data,
c_voidp dest)
{
c_type refType;
c_class cls;
c_array references, labels, ar, destar;
c_sequence seq, destseq;
c_property property;
c_member member;
c_long i,j,length,size;
c_long nrOfRefs,nrOfLabs;
c_value v;
switch (c_baseObject(type)->kind) {
case M_CLASS:
cls = c_class(type);
while (cls) {
length = c_arraySize(c_interface(cls)->references);
for (i=0;i<length;i++) {
property = c_property(c_interface(cls)->references[i]);
refType = property->type;
_cloneReference(refType,
C_DISPLACE(data, property->offset),
C_DISPLACE(dest, property->offset));
}
cls = cls->extends;
}
break;
case M_INTERFACE:
length = c_arraySize(c_interface(type)->references);
for (i=0;i<length;i++) {
property = c_property(c_interface(type)->references[i]);
refType = property->type;
_cloneReference(refType,
C_DISPLACE(data, property->offset),
C_DISPLACE(dest, property->offset));
}
break;
case M_EXCEPTION:
case M_STRUCTURE:
length = c_arraySize(c_structure(type)->references);
for (i=0;i<length;i++) {
member = c_member(c_structure(type)->references[i]);
refType = c_specifier(member)->type;
_cloneReference(refType,
C_DISPLACE(data, member->offset),
C_DISPLACE(dest, member->offset));
}
break;
case M_UNION:
#define _CASE_(k,t) case k: v = t##Value(*((t *)data)); break
switch (c_metaValueKind(c_metaObject(c_union(type)->switchType))) {
_CASE_(V_BOOLEAN, c_bool);
_CASE_(V_OCTET, c_octet);
_CASE_(V_SHORT, c_short);
_CASE_(V_LONG, c_long);
_CASE_(V_LONGLONG, c_longlong);
_CASE_(V_USHORT, c_ushort);
_CASE_(V_ULONG, c_ulong);
_CASE_(V_ULONGLONG, c_ulonglong);
_CASE_(V_CHAR, c_char);
_CASE_(V_WCHAR, c_wchar);
default:
OS_REPORT(OS_ERROR,
"c__cloneReferences",0,
"illegal union switch type detected");
assert(FALSE);
return FALSE;
break;
}
#undef _CASE_
references = c_union(type)->references;
if (references != NULL) {
i=0; refType=NULL;
nrOfRefs = c_arraySize(references);
while ((i<nrOfRefs) && (refType == NULL)) {
labels = c_unionCase(references[i])->labels;
j=0;
nrOfLabs = c_arraySize(labels);
while ((j<nrOfLabs) && (refType == NULL)) {
if (c_valueCompare(v,c_literal(labels[j])->value) == C_EQ) {
c__cloneReferences(c_type(references[i]),
C_DISPLACE(data, c_type(type)->alignment),
C_DISPLACE(dest, c_type(type)->alignment));
refType = c_specifier(references[i])->type;
}
j++;
}
i++;
}
}
break;
case M_COLLECTION:
refType = c_typeActualType(c_collectionType(type)->subType);
switch (c_collectionType(type)->kind) {
case C_ARRAY:
ar = c_array(data);
destar = c_array(dest);
length = c_collectionType(type)->maxSize;
if (length == 0) {
length = c_arraySize(ar);
}
if (c_typeIsRef(refType)) {
for (i=0;i<length;i++) {
c_cloneIn(refType, ar[i], &destar[i]);
}
} else {
if (c_typeHasRef(refType)) {
size = refType->size;
for (i=0;i<length;i++) {
_cloneReference(refType, C_DISPLACE(data, (i*size)), C_DISPLACE(dest, (i*size)));
}
}
}
break;
case C_SEQUENCE:
seq = c_sequence(data);
destseq = c_sequence(dest);
length = c_sequenceSize(seq);
if (c_typeIsRef(refType)) {
for (i=0;i<length;i++) {
c_cloneIn(refType, seq[i], &destseq[i]);
}
} else {
if (c_typeHasRef(refType)) {
size = refType->size;
for (i=0;i<length;i++) {
_cloneReference(refType, C_DISPLACE(seq, (i*size)), C_DISPLACE(dest, (i*size)));
}
}
}
break;
default:
OS_REPORT(OS_ERROR,
"c__cloneReferences",0,
"illegal collectionType found");
break;
}
break;
case M_BASE:
break;
case M_TYPEDEF:
c__cloneReferences(c_type(c_typeDef(type)->alias), data, dest);
break;
case M_ATTRIBUTE:
case M_RELATION:
refType = c_typeActualType(c_property(type)->type);
_cloneReference(refType,
C_DISPLACE(data, c_property(type)->offset),
C_DISPLACE(dest, c_property(type)->offset));
break;
case M_MEMBER:
refType = c_typeActualType(c_specifier(type)->type);
_cloneReference(refType,
C_DISPLACE(data, c_member(type)->offset),
C_DISPLACE(dest, c_member(type)->offset));
break;
case M_UNIONCASE:
refType = c_typeActualType(c_specifier(type)->type);
_cloneReference(refType, data, dest);
break;
case M_MODULE:
/* Do nothing */
break;
case M_PRIMITIVE:
/* Do nothing */
break;
case M_EXTENT:
case M_EXTENTSYNC:
default:
OS_REPORT(OS_ERROR,
"c__cloneReferences",0,
"illegal meta object specified");
assert(FALSE);
return FALSE;
}
return TRUE;
}
void
c_cloneIn (
c_type type,
c_voidp data,
c_voidp *dest)
{
c_long size,subSize;
c_type t;
if (data == NULL) {
*dest = NULL;
return;
}
t = c_typeActualType(type);
if (c_baseObject(t)->kind == M_COLLECTION) {
switch(c_collectionType(t)->kind) {
case C_STRING:
*dest = c_stringNew(c_getBase(t), data);
break;
case C_LIST:
case C_BAG:
case C_SET:
case C_MAP:
case C_DICTIONARY:
OS_REPORT(OS_WARNING,"Database misc",0,
"c_cloneIn: ODL collections unsupported");
break;
case C_ARRAY:
subSize = c_collectionType(t)->subType->size;
size = c_collectionType(t)->maxSize;
if (size == 0) {
size = c_arraySize(data);
*dest = c_newArray(c_collectionType(t), size);
}
if (size > 0) {
memcpy(*dest, data, size * subSize);
/* Find indirections */
c__cloneReferences(t, data, dest);
}
break;
case C_SEQUENCE:
subSize = c_collectionType(t)->subType->size;
size = c_sequenceSize(data);
if (size > 0) {
*dest = c_newSequence(c_collectionType(t), size);
memcpy(*dest, data, size * subSize);
/* Find indirections */
c__cloneReferences(t, data, dest);
}
break;
break;
default:
OS_REPORT_1(OS_ERROR,"Database misc",0,
"c_cloneIn: unknown collection kind (%d)",
c_collectionType(t)->kind);
assert(FALSE);
break;
}
} else if (c_typeIsRef(t)) {
*dest = c_new(t);
memcpy(*dest, data, t->size);
/* Find indirections */
c__cloneReferences(t, data, *dest);
} else {
memcpy(*dest, data, t->size);
/* Find indirections */
c__cloneReferences(t, data, *dest);
}
}
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;
}
void
c_copyOut (
c_type type,
c_object o,
c_voidp *data)
{
c_long i,size;
c_type t,subType;
if (data == NULL) {
OS_REPORT(OS_ERROR,"Database misc",0,
"c_copyOut: no destination specified");
return;
}
if (o == NULL) {
*data = NULL;
return;
}
t = c_typeActualType(type);
size = c_typeSize(t);
if (size == 0) {
OS_REPORT(OS_WARNING,"Database misc",0,
"c_copyOut: zero sized type specified");
*data = NULL;
return;
}
if (*data == NULL) {
*data = (c_voidp)os_malloc(size);
}
if (c_baseObject(t)->kind == M_COLLECTION) {
switch(c_collectionType(t)->kind) {
case C_STRING:
*data = os_strdup((c_char *)o);
break;
case C_LIST:
case C_BAG:
case C_SET:
case C_MAP:
case C_DICTIONARY:
OS_REPORT(OS_WARNING,"Database misc",0,
"c_copyOut: ODL collections unsupported");
assert(FALSE);
break;
case C_ARRAY:
size = c_collectionType(t)->maxSize;
if (size > 0) {
subType = c_collectionType(t)->subType;
for (i=0;i<size;i++) {
c_copyIn(subType,
((c_voidp *)o)[i],
&((c_voidp *)(*data))[i]);
}
} else {
OS_REPORT(OS_WARNING,"Database misc",0,
"c_copyOut: dynamic sized arrays unsupported");
}
case C_SEQUENCE:
OS_REPORT(OS_WARNING,"Database misc",0,
"c_copyOut: sequences unsupported");
assert(FALSE);
break;
default:
OS_REPORT_1(OS_ERROR,"Database misc",0,
"c_copyOut: unknown collection kind (%d)",
c_collectionType(t)->kind);
assert(FALSE);
break;
}
} else if (c_typeIsRef(t)) {
memcpy(*data,*(void**)o,size);
extractReferences(t,*(void**)o,*data);
} else {
memcpy(*data,o,size);
extractReferences(t,o,*data);
}
}
/*
* 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;
}
void
c_copyIn (
c_type type,
c_voidp data,
c_voidp *dest)
{
c_long size, subSize, i;
c_type t, refType;
if (data == NULL) {
*dest = NULL;
return;
}
t = c_typeActualType(type);
if (c_baseObject(t)->kind == M_COLLECTION) {
switch(c_collectionType(t)->kind) {
case C_STRING:
*dest = c_stringNew(c_getBase(t),data);
return;
case C_LIST:
case C_BAG:
case C_SET:
case C_MAP:
case C_DICTIONARY:
OS_REPORT(OS_WARNING,"Database misc",0,
"c_copyIn: ODL collections unsupported");
break;
case C_ARRAY:
refType = c_typeActualType(c_collectionType(type)->subType);
subSize = refType->size;
size = c_collectionType(t)->maxSize;
if (size == 0) {
size = c_arraySize(data);
*dest = c_newArray(c_collectionType(t), size);
}
if (size > 0) {
c_array ar = c_array(data);
c_array destar = c_array(*dest);
if (c_typeIsRef(refType)) {
for (i = 0; i < size; i++) {
copyReferences(refType, destar[i], ar[i]);
}
} else {
memcpy(*dest, data, size * subSize);
/* Find indirections */
for (i = 0; i < size; i++) {
copyReferences(refType, C_DISPLACE(destar, (i*subSize)), C_DISPLACE(ar, (i*subSize)));
}
}
}
break;
case C_SEQUENCE:
refType = c_typeActualType(c_collectionType(type)->subType);
subSize = refType->size;
size = c_sequenceSize(data);
if (size > 0) {
*dest = c_newSequence(c_collectionType(t), size);
if (c_typeIsRef(refType)) {
c_sequence seq = c_sequence(data);
c_sequence destseq = c_sequence(*dest);
for (i = 0; i < size; i++) {
copyReferences(refType, destseq[i], seq[i]);
}
} else {
memcpy(*dest, data, size * subSize);
/* Find indirections */
for (i = 0; i < size; i++) {
copyReferences(refType, C_DISPLACE(*dest, (i*subSize)), C_DISPLACE(data, (i*subSize)));
}
}
}
break;
default:
OS_REPORT_1(OS_ERROR,"Database misc",0,
"c_copyIn: unknown collection kind (%d)",
c_collectionType(t)->kind);
assert(FALSE);
break;
}
} else if (c_typeIsRef(t)) {
*dest = c_new(t);
memcpy(*dest, data, t->size);
copyReferences(t, *dest, data);
} else {
memcpy(*dest, data, t->size);
copyReferences(t, *dest, data);
}
}
c_bool
__sensor_msgs_msg_dds__CameraInfo___copyIn(
c_base base,
struct ::sensor_msgs::msg::dds_::CameraInfo_ *from,
struct _sensor_msgs_msg_dds__CameraInfo_ *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_);
}
to->height_ = (c_ulong)from->height_;
to->width_ = (c_ulong)from->width_;
#ifdef OSPL_BOUNDS_CHECK
if(from->distortion_model_){
to->distortion_model_ = c_stringNew(base, from->distortion_model_);
} else {
OS_REPORT (OS_ERROR, "copyIn", 0,"Member 'sensor_msgs::msg::dds_::CameraInfo_.distortion_model_' of type 'c_string' is NULL.");
result = OS_C_FALSE;
}
#else
to->distortion_model_ = c_stringNew(base, from->distortion_model_);
#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_double *dest0;
::sensor_msgs::msg::dds_::CameraInfo_::_d__seq *src = &from->d_;
if (type0 == NULL) {
subtype0 = c_type(c_metaResolve (c_metaObject(base), "c_double"));
type0 = c_metaSequenceTypeNew(c_metaObject(base),"C_SEQUENCE<c_double>",subtype0,0);
c_free(subtype0);
}
length0 = (c_long)(*src).length();
#ifdef OSPL_BOUNDS_CHECK
dest0 = (c_double *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_double *buf0;
buf0 = (c_double *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->d_ = (c_sequence)dest0;
#else
dest0 = (c_double *)c_newSequence(c_collectionType(type0),length0);
{
/* Code generated by /home/erle/opensplice/src/tools/idlpp/code/idl_genCorbaCxxCopyin.c at line 1873 */
c_double *buf0;
buf0 = (c_double *)(*src).get_buffer();
memcpy (dest0,buf0,length0* sizeof(*dest0));
}
to->d_ = (c_sequence)dest0;
#endif
}
if(result){
extern c_bool __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9__copyIn(c_base, ::sensor_msgs::msg::dds_::sensor_msgs__CameraInfo__double_array_9 *, _sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9 *);
result = __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9__copyIn(base, &from->k_, &to->k_);
}
if(result){
extern c_bool __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9__copyIn(c_base, ::sensor_msgs::msg::dds_::sensor_msgs__CameraInfo__double_array_9 *, _sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9 *);
result = __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_9__copyIn(base, &from->r_, &to->r_);
}
if(result){
extern c_bool __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_12__copyIn(c_base, ::sensor_msgs::msg::dds_::sensor_msgs__CameraInfo__double_array_12 *, _sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_12 *);
result = __sensor_msgs_msg_dds__sensor_msgs__CameraInfo__double_array_12__copyIn(base, &from->p_, &to->p_);
}
to->binning_x_ = (c_ulong)from->binning_x_;
to->binning_y_ = (c_ulong)from->binning_y_;
if(result){
extern c_bool __sensor_msgs_msg_dds__RegionOfInterest___copyIn(c_base, ::sensor_msgs::msg::dds_::RegionOfInterest_ *, _sensor_msgs_msg_dds__RegionOfInterest_ *);
result = __sensor_msgs_msg_dds__RegionOfInterest___copyIn(base, &from->roi_, &to->roi_);
}
return result;
}
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;
}
static void
metaobject (
c_metaObject o,
monitor_trc trace
)
{
refLeaf ted;
if (c_baseObject(o)->kind < M_COUNT) {
switch (c_baseObject(o)->kind) {
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:
break;
case M_COLLECTION:
switch (c_collectionType(o)->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) {
ted = monitor_typeExtent (c_type(o), trace);
if (ted) {
if ((ted->ec - ted->ecp) >= trace->objectCountLimit) {
if (trace->filterExpression) {
if (strstr (o->name, trace->filterExpression) == NULL) {
break;
}
}
printf ("%6d (%8d) %8d %12lld %-15s %-15s ",
ted->ec - ted->ecp,
ted->ec,
c_type(o)->size,
(long long)(c_type(o)->size * (long long)((int)ted->ec - (int)ted->ecp)),
baseKind[c_baseObject(o)->kind],
collectionKind[c_collectionType(o)->kind]);
printScope (o->definedIn);
printf ("::%s\r\n", o->name);
trace->totalCount += c_type(o)->size * (ted->ec - ted->ecp);
trace->totalExtentCount += ted->ec - ted->ecp;
trace->index++;
}
}
} else {
if (c_type(o)->objectCount >= trace->objectCountLimit) {
if (trace->filterExpression) {
if (strstr (o->name, trace->filterExpression) == NULL) {
break;
}
}
printf ("%8d %8d %12lld %-15s %-15s ",
c_type(o)->objectCount,
c_type(o)->size,
(long long)((long long)c_type(o)->size * c_type(o)->objectCount),
baseKind[c_baseObject(o)->kind],
collectionKind[c_collectionType(o)->kind]);
printScope (o->definedIn);
printf ("::%s\r\n", o->name);
trace->totalCount += c_type(o)->size * c_type(o)->objectCount;
trace->totalExtentCount += c_type(o)->objectCount;
trace->index++;
}
}
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:
if (trace->delta) {
ted = monitor_typeExtent (c_type(o), trace);
if (ted) {
if ((ted->ec - ted->ecp) >= trace->objectCountLimit) {
if (trace->filterExpression) {
if (strstr (o->name, trace->filterExpression) == NULL) {
break;
}
}
printf ("%6d (%8d) %8d %12lld %-15s ",
ted->ec - ted->ecp,
ted->ec,
c_type(o)->size,
(long long)(c_type(o)->size * (long long)((int)ted->ec - (int)ted->ecp)),
baseKind[c_baseObject(o)->kind]);
printf (" ");
printScope (o->definedIn);
printf ("::%s\r\n", o->name);
trace->totalCount += c_type(o)->size * (ted->ec - ted->ecp);
trace->totalExtentCount += ted->ec - ted->ecp;
trace->index++;
}
}
} else {
if (c_type(o)->objectCount >= trace->objectCountLimit) {
if (trace->filterExpression) {
if (strstr (o->name, trace->filterExpression) == NULL) {
break;
}
}
printf ("%8d %8d %12lld %-15s ",
c_type(o)->objectCount,
c_type(o)->size,
(long long)((long long)c_type(o)->size * c_type(o)->objectCount),
baseKind[c_baseObject(o)->kind]);
printf (" ");
printScope (o->definedIn);
printf ("::%s\r\n", o->name);
trace->totalCount += c_type(o)->size * c_type(o)->objectCount;
trace->totalExtentCount += c_type(o)->objectCount;
trace->index++;
}
}
break;
case M_MODULE:
c_metaWalk (o, metaobject, trace);
}
}
}
