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;
}
static c_bool
walkCompare (
c_binding binding,
c_walkArg arg)
{
if (arg->compare (c_baseObject(binding->object), arg->arg) == E_EQUAL) {
arg->object = c_baseObject(binding->object);
return FALSE;
}
return TRUE;
}
c_baseObject
c_scopeResolve(
c_scope scope,
const char *name,
c_long metaFilter)
{
c_metaObject o = NULL;
struct c_walkArg warg;
struct c_findArg farg;
if (scope == NULL) {
return NULL;
}
if (metaFilter & CQ_CASEINSENSITIVE) {
warg.arg = &farg;
warg.compare = c_metaNameCompare;
warg.object = NULL;
farg.name = name;
farg.metaFilter = metaFilter;
farg.object = NULL;
if (c_avlTreeWalk(c_avlTree(scope),walkCompare,&warg,C_POSTFIX) == FALSE) {
if (warg.object) {
o = c_keep(warg.object);
}
} else {
o = NULL;
}
} else {
o = c_scopeLookup(scope, name, metaFilter);
}
return c_baseObject(o);
}
c_structure
idl_stacDefFindMetaStructureResolved(
c_metaObject scope,
const char *typeName)
{
c_baseObject object;
c_structure structure;
object = c_baseObject(c_metaResolve(scope, typeName));
if(!object)
{
printf("FATAL ERROR | #pragma stac: Trying to locate structure '%s' in "
"scope '%s'. But no such object exists.\n",
typeName, c_metaScopedName(c_metaObject(scope)));
exit(-2);
}
/* Resolve typedefs */
idl_stacDefResolveTypeDef(object);
/* The final object (after typedef resolving) should be a structure */
if(object->kind != M_STRUCTURE)
{
printf("FATAL ERROR | #pragma stac: Trying to locate structure '%s' in "
"scope '%s'. But the identified object is not a structure.\n",
typeName, c_metaScopedName(c_metaObject(scope)));
exit(-2);
}
structure = c_structure(object);
return structure;
}
static void
orderedWalk (
c_metaObject o,
monitor_trc trace
)
{
switch (c_baseObject(o)->kind) {
case M_MODULE:
c_metaWalk (o, orderedWalk, trace);
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:
break;
default:
ut_tableInsert(ut_table(trace->orderedList), o, o);
break;
}
}
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_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;
}
static void
extractStructReferences(
c_structure m,
c_object o,
void *data)
{
c_long i,length;
c_member member;
c_type type;
c_object *ref;
if (m->references == NULL) return;
length = c_arraySize(m->references);
for (i=0;i<length;i++) {
member = c_member(m->references[i]);
type = c_typeActualType(c_specifier(member)->type);
while (c_baseObject(type)->kind == M_TYPEDEF) {
type = c_typeDef(type)->alias;
}
switch (c_baseObject(type)->kind) {
case M_CLASS:
case M_INTERFACE:
case M_COLLECTION:
case M_BASE:
ref = C_DISPLACE(data,member->offset);
*ref = NULL;
c_copyOut(type,C_REFGET(o,member->offset),ref);
break;
case M_EXCEPTION:
case M_STRUCTURE:
case M_UNION:
copyReferences(type,C_DISPLACE(o,member->offset),
C_DISPLACE(data,member->offset))
;
break;
default:
assert(FALSE);
break;
}
}
}
c_baseObject
idl_stacDefResolveTypeDef(
c_baseObject obj)
{
c_baseObject object;
object = obj;
while(object->kind == M_TYPEDEF)
{
object = c_baseObject(c_typeDef(object)->alias);
}
return object;
}
static c_bool
sd_deepwalkInterface(
c_metaObject object,
c_metaWalkActionArg actionArg)
{
sd_interfaceContext context = (sd_interfaceContext)actionArg;
c_property property;
c_object propertyData;
/* For now, we are interested in properties only */
assert(c_baseObject(object)->kind == M_ATTRIBUTE);
property = c_property(object);
propertyData = C_DISPLACE(*context->objectPtr, property->offset);
sd_deepwalkType(property->type, &propertyData,
context->action, context->actionArg);
return TRUE;
}
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;
}
/** \brief Function for selecting the correct switch value for a given
* union object
*/
static c_value
sd_unionDetermineSwitchValue(
c_type switchType,
c_object object)
{
c_value switchValue;
switch (c_baseObject(switchType)->kind) {
case M_PRIMITIVE:
switch (c_primitive(switchType)->kind) {
#define __CASE__(prim, type) case prim: switchValue = type##Value(*((type *)object)); break;
__CASE__(P_ADDRESS,c_address)
__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();
SD_CONFIDENCE(FALSE);
break;
}
break;
case M_ENUMERATION:
switchValue = c_longValue(*(c_long *)object);
break;
default:
switchValue = c_undefinedValue();
SD_CONFIDENCE(FALSE);
break;
}
return switchValue;
/* QAC EXPECT 5101; cyclomatic complexity is high because of switch statement */
}
static void
copyInterfaceReferences(
c_interface m,
c_voidp dest,
c_voidp data)
{
c_long i,length;
c_property property;
c_type type;
c_object *ref;
if (m->references == NULL) {
return;
}
length = c_arraySize(m->references);
for (i=0;i<length;i++) {
property = c_property(m->references[i]);
type = c_typeActualType(property->type);
switch (c_baseObject(type)->kind) {
case M_CLASS:
case M_INTERFACE:
case M_COLLECTION:
case M_BASE:
ref = C_DISPLACE(dest,property->offset);
c_copyIn(type,C_REFGET(data,property->offset),ref);
break;
case M_EXCEPTION:
case M_STRUCTURE:
case M_UNION:
copyReferences(type,C_DISPLACE(dest,property->offset),
C_DISPLACE(data,property->offset));
break;
default:
assert(FALSE);
break;
}
}
}
static c_bool
c_deepwalkProperty(
c_metaObject object,
c_metaWalkActionArg actionArg)
{
c_interfaceContext context = (c_interfaceContext)actionArg;
c_property property;
c_type propertyType;
c_object propertyData;
/* For now, we are interested in properties only */
if (c_baseObject(object)->kind == M_ATTRIBUTE) {
property = c_property(object);
propertyType = c_typeActualType(property->type);
/* For now, skip attributes which are class-references */
propertyData = C_DISPLACE(*context->objectPtr,
(c_address)property->offset);
c_deepwalkType(propertyType, &propertyData,
context->action, context->actionArg);
}
return TRUE;
}
/* Non-static for reuse by descendants */
c_char *
sd_getTagName(
const c_char *name,
c_type type)
{
c_char *result;
if (name) {
result = sd_stringDup(name);
} else {
switch (c_baseObject(type)->kind) {
case M_STRUCTURE:
case M_INTERFACE:
case M_CLASS:
result = sd_getScopedTypeName(type, "..");
break;
default:
result = sd_stringDup(SD_ELEMENT_NAME);
break;
}
}
return result;
}
/**************************************************************
* 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);
}
}
/* 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 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);
}
}
}
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);
}
}
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;
}
/*
* 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_char *
idl_genJavaLiteralValueImage(
c_value literal,
c_type type)
{
c_char * valueImg = NULL;
c_char *val2;
int i;
if (c_baseObject(type)->kind != M_ENUMERATION) {
switch (literal.kind) {
case V_OCTET:
valueImg = os_malloc (40);
snprintf(valueImg, 40, "%d", literal.is.Octet);
break;
case V_FLOAT:
case V_DOUBLE:
val2 = os_malloc(45);
valueImg = os_malloc(45);
snprintf(val2, 45, "%40.17g", literal.is.Double);
i = 0;
while (val2[i] == ' ') {
i++;
}
os_strncpy(valueImg, &val2[i], 40);
os_free(val2);
if ((strchr(valueImg, '.') == NULL) && (strchr(valueImg, 'E') == NULL)) {
strcat(valueImg, ".0");
}
break;
case V_STRING:
valueImg = os_malloc(strlen(literal.is.String)+3);
snprintf(valueImg, strlen(literal.is.String)+3, "\"%s\"", literal.is.String);
break;
case V_BOOLEAN:
valueImg = os_malloc(40);
if (literal.is.Boolean) {
snprintf(valueImg, 40, "true");
} else {
snprintf (valueImg, 40, "false");
}
break;
case V_LONGLONG:
valueImg = os_malloc(40);
switch (c_primitive(type)->kind) {
case P_SHORT:
/* Apply unsigned version, since sign will be applied later as additional minus operand. */
snprintf(valueImg, 40, "%hu", (c_short)literal.is.LongLong);
break;
case P_USHORT:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
snprintf(valueImg, 40, "%hd", (c_short)literal.is.LongLong);
break;
case P_LONG:
/* Apply unsigned version, since sign will be applied later as additional minus operand. */
snprintf(valueImg, 40, "%u", (c_long)literal.is.LongLong);
break;
case P_ULONG:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
snprintf(valueImg, 40, "%d", (c_long)literal.is.LongLong);
break;
case P_LONGLONG:
/* Apply unsigned version, since sign will be applied later as additional minus operand. */
snprintf(valueImg, 40, "%"PA_PRIu64"L", (c_longlong)literal.is.LongLong);
break;
case P_ULONGLONG:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
snprintf(valueImg, 40, "%"PA_PRId64"L", (c_longlong)literal.is.LongLong);
break;
case P_CHAR:
snprintf(valueImg, 40, "%d", (unsigned char)literal.is.LongLong);
break;
case P_OCTET:
snprintf(valueImg, 40, "%d", (unsigned char)literal.is.LongLong);
break;
case P_ADDRESS:
snprintf(valueImg, 40, PA_ADDRFMT, (PA_ADDRCAST)literal.is.LongLong);
break;
case P_UNDEFINED:
case P_BOOLEAN:
case P_WCHAR:
case P_FLOAT:
case P_DOUBLE:
case P_VOIDP:
case P_MUTEX:
case P_LOCK:
case P_COND:
case P_COUNT:
case P_PA_UINT32:
case P_PA_UINTPTR:
case P_PA_VOIDP:
/* Do nothing */
break;
}
break;
case V_SHORT:
/* Apply unsigned version, since sign will be applied later as additional minus operand. */
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%hu", literal.is.Short);
break;
case V_LONG:
/* Apply unsigned version, since sign will be applied later as additional minus operand. */
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%u", (c_long)literal.is.Long);
break;
case V_USHORT:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%hd", (c_short)literal.is.UShort);
break;
case V_ULONG:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%d", (c_long)literal.is.ULong);
break;
case V_ULONGLONG:
/* Apply signed version, since Java has no unsigned types and therefore needs to
* overflow into the negative range. */
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%" PA_PRId64, (c_longlong)literal.is.ULongLong);
break;
case V_ADDRESS:
valueImg = os_malloc(40);
snprintf(valueImg, 40, PA_ADDRFMT, (PA_ADDRCAST)literal.is.Address);
break;
case V_CHAR:
valueImg = os_malloc(40);
snprintf(valueImg, 40, "%u", (unsigned char)literal.is.Char);
break;
case V_UNDEFINED:
case V_WCHAR:
case V_WSTRING:
case V_FIXED:
case V_VOIDP:
case V_OBJECT:
case V_COUNT:
/* Invalid types for literal constants*/
/* FALL THROUGH */
default:
valueImg = NULL;
break;
}
} else {
const char *ENUM_TEMPLATE = "%s.%s";
char *javaEnumTp = idl_javaId(c_metaObject(type)->name);
char *javaEnumLabel = idl_javaId(c_metaObject(c_enumeration(type)->elements[literal.is.Long])->name);
size_t valLen = strlen(javaEnumTp) + strlen(javaEnumLabel) + strlen(ENUM_TEMPLATE) + 1;
valueImg = os_malloc(valLen);
snprintf(valueImg, valLen, ENUM_TEMPLATE, javaEnumTp, javaEnumLabel);
os_free(javaEnumTp);
os_free(javaEnumLabel);
}
return valueImg;
}
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_field
c_fieldNew (
c_type type,
const c_char *fieldName)
{
c_array path;
c_field field;
c_metaObject o;
c_long n,length;
c_address offset;
c_iter nameList, refsList;
c_string name;
c_base base;
if ((fieldName == NULL) || (type == NULL)) {
OS_REPORT(OS_ERROR,
"c_fieldNew failed",0,
"illegal parameter");
return NULL;
}
base = c__getBase(type);
if (base == NULL) {
OS_REPORT(OS_ERROR,
"c_fieldNew failed",0,
"failed to retreive base");
return NULL;
}
nameList = c_splitString(fieldName,".");
length = c_iterLength(nameList);
field = NULL;
if (length > 0) {
o = NULL;
offset = 0;
refsList = NULL;
path = c_newArray(c_fieldPath_t(base),length);
if (path) {
for (n=0;n<length;n++) {
name = c_iterTakeFirst(nameList);
o = c_metaResolve(c_metaObject(type),name);
os_free(name);
if (o == NULL) {
c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL);
c_iterFree(nameList);
c_iterFree(refsList);
c_free(path);
return NULL;
}
path[n] = o;
switch (c_baseObject(o)->kind) {
case M_ATTRIBUTE:
case M_RELATION:
type = c_property(o)->type;
offset += c_property(o)->offset;
break;
case M_MEMBER:
type = c_specifier(o)->type;
offset += c_member(o)->offset;
break;
default:
c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL);
c_iterFree(nameList);
c_iterFree(refsList);
c_free(path);
return NULL;
}
switch (c_baseObject(type)->kind) {
case M_INTERFACE:
case M_CLASS:
case M_COLLECTION:
/*Longs are inserted in an iterator? Explanation please...*/
refsList = c_iterInsert(refsList,(c_voidp)offset);
offset = 0;
break;
default:
break;
}
}
if (offset > 0) {
refsList = c_iterInsert(refsList,(c_voidp)offset);
}
field = c_new(c_field_t(base));
field->name = c_stringNew(base,fieldName);
field->path = path;
field->type = c_keep(type);
field->kind = c_metaValueKind(o);
field->refs = NULL;
if (refsList) {
length = c_iterLength(refsList);
field->offset = 0;
if (length > 0) {
field->refs = c_newArray(c_fieldRefs_t(base),length);
if (field->refs) {
for (n=(length-1);n>=0;n--) {
field->refs[n] = c_iterTakeFirst(refsList);
}
} else {
OS_REPORT(OS_ERROR,
"c_fieldNew failed",0,
"failed to allocate field->refs array");
c_free(field);
field = NULL;
}
}
c_iterFree(refsList);
} else {
field->offset = offset;
}
} else {
OS_REPORT(OS_ERROR,
"c_fieldNew failed",0,
"failed to allocate field->path array");
c_iterWalk(nameList,(c_iterWalkAction)os_free,NULL);
c_iterFree(nameList);
}
c_iterFree(nameList);
} else {
OS_REPORT_1(OS_ERROR,
"c_fieldNew failed",0,
"failed to process field name <%s>",
fieldName);
}
return field;
}
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;
}
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;
}
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);
}
}
