IPC_RETURN_TYPE IPC_defineMsg (const char *msgName, unsigned int length,
const char *formatString)
{
char msgFormat[20];
if (!msgName || strlen(msgName) == 0) {
RETURN_ERROR(IPC_Null_Argument);
} else if (!X_IPC_CONNECTED()) {
RETURN_ERROR(IPC_Not_Connected);
} if (length != (unsigned int)IPC_VARIABLE_LENGTH && formatString != NULL &&
length != (unsigned int)x_ipc_dataStructureSize(ParseFormatString(formatString))) {
RETURN_ERROR(IPC_Mismatched_Formatter);
} else {
if (length == IPC_VARIABLE_LENGTH) {
sprintf(msgFormat, "{int, <byte:1>}");
} else if (length == 0) {
msgFormat[0] = '\0';
} else {
sprintf(msgFormat, "[byte:%d]", length);
}
x_ipcRegisterMessage(msgName, BroadcastClass, msgFormat, formatString);
return IPC_OK;
}
}
void *x_ipcReferenceData(X_IPC_REF_PTR ref)
{
int32 refId, sd;
MSG_PTR msg;
char *msgData;
X_IPC_REF_PTR waitRef;
X_IPC_RETURN_VALUE_TYPE returnValue;
msg = x_ipc_msgFind(X_IPC_REF_DATA_QUERY);
if (msg == NULL) return NULL;
if (!ref->msg) {
if (!ref->name) {
/* 17-Jun-91: fedor: start enforcing correct refs */
X_IPC_MOD_ERROR1("ERROR: x_ipcReferenceData: Badly Formed Reference: %d\n",
ref->refId);
return NULL;
}
ref->msg = x_ipc_msgFind(ref->name);
if (ref->msg == NULL) return NULL;
}
/* 17-Jun-91: fedor: check if any message form */
if (!ref->msg->msgData->msgFormat)
return NULL;
refId = x_ipc_nextSendMessageRef();
returnValue = x_ipc_sendMessage((X_IPC_REF_PTR)NULL, msg,
(char *)&ref->refId, (char *)NULL, refId);
if (returnValue != Success) {
X_IPC_MOD_ERROR("ERROR: x_ipcReferenceData: x_ipc_sendMessage Failed.\n");
return NULL;
}
waitRef = x_ipcRefCreate(ref->msg, ref->name, refId);
msgData = (char *)x_ipcMalloc((unsigned)x_ipc_dataStructureSize(ref->msg->msgData->msgFormat));
LOCK_CM_MUTEX;
sd = GET_C_GLOBAL(serverRead);
UNLOCK_CM_MUTEX;
returnValue = x_ipc_waitForReplyFrom(waitRef, msgData, TRUE, WAITFOREVER, sd);
x_ipcRefFree(waitRef);
if (returnValue == NullReply) {
/* 17-Jun-91: fedor: if NullReply then nothing else was malloced. */
x_ipcFree(msgData);
return NULL;
}
else
return msgData;
}
static int32 printArrayData(FILE *stream, Print_Data_Ptr printer,
CONST_FORMAT_PTR format,
const void *dataArray,
int32 AStart, FORMAT_ARRAY_PTR formatArray,
int32 dimension, int32 keepWithNext,
char *startToken, char *endToken)
{
int32 i, element_size=0, last_dimension_p, last_element_p;
int32 vector_length, next_keep;
printString(stream, printer, startToken, DEFAULT_KEEP);
last_dimension_p = (dimension+1 == formatArray[0].i);
if (last_dimension_p)
element_size = x_ipc_dataStructureSize(format);
vector_length = formatArray[dimension].i;
for (i=0; i<vector_length; i++) {
if (printer->truncatedGlobal)
return 0;
else {
last_element_p = (i+1 == vector_length);
next_keep = ((last_element_p) ? keepWithNext+1 : 1);
if (last_dimension_p) {
Print_Structured_Data(stream, printer, format,
(CONST_GENERIC_DATA_PTR)dataArray,
AStart, (FORMAT_PTR)NULL, next_keep);
AStart += element_size;
if (!last_element_p)
printCommaSpace(stream, printer);
}
else {
AStart = printArrayData(stream, printer, format, dataArray, AStart,
formatArray, dimension+1, next_keep,
startToken, endToken);
if (!last_element_p)
printCommaSpace(stream, printer);
}
}
}
printString(stream, printer, endToken, keepWithNext);
return AStart;
}
int main (int argc, char **argv)
#endif
{
#ifndef VXWORKS
int numTrials;
char *formatString;
#endif
int i;
FORMATTER_PTR format;
char data[MAX_DATA_SIZE]; /* No error checking if the format is too big */
void *dataPtr;
IPC_VARCONTENT_TYPE vc;
bzero(data, MAX_DATA_SIZE);
#ifndef VXWORKS
if (argc == 1) {
fprintf(stderr, "Usage %s: <format_string> [num_trials]\n", argv[0]);
exit(-1);
}
formatString = argv[1];
numTrials = (argc > 2 ? atoi(argv[2]) : DEFAULT_TRIALS);
#endif
IPC_initialize();
format = IPC_parseFormat(formatString);
if (!format) {
fprintf(stderr, "Illegal format string: %s\n", formatString);
exit(-1);
}
/* Marshall tests */
printf("Marshalling trial with %s\n", formatString);
printf(" Struct Size: %d, Buffer Size: %d (%s size)\n",
x_ipc_dataStructureSize(format),
(formatContainsPointers(format) ? -1 : x_ipc_bufferSize(format, NULL)),
(x_ipc_sameFixedSizeDataBuffer(format) ? "fixed" : "variable"));
TIME_TRIAL({ IPC_marshall(format, &data, &vc);
IPC_freeByteArray(vc.content);})
static void Print_Structured_Data(FILE *Stream, Print_Data_Ptr printer,
CONST_FORMAT_PTR Format,
CONST_GENERIC_DATA_PTR Data_Ptr,
int32 DStart,
CONST_FORMAT_PTR parentFormat,
int32 Keep_With_Next)
{
TRANSLATE_FN_DPRINT printProc;
int32 i, last_element_p, next_keep, length, currentDStart;
u_int32 byte;
void *StructPtr, *ArrayPtr;
FORMAT_ARRAY_PTR format_array, fixed_format_array;
currentDStart = DStart;
switch (Format->type) {
case LengthFMT:
length = Format->formatter.i;
printString(Stream, printer, "(", DEFAULT_KEEP);
for (i=0; i<length; i++) {
if (printer->truncatedGlobal) {
return;
} else {
byte = 0;
*(((u_char *)&byte)+sizeof(u_int32)-sizeof(u_char)) =
*(u_char *)(Data_Ptr+currentDStart+i);
printHex(Stream, printer, &byte,
(i == length-1 ? Keep_With_Next+1 : 1));
if (i == length-1) printString(Stream, printer, ")", Keep_With_Next);
else printCommaSpace(Stream, printer);
}
}
break;
case PrimitiveFMT:
printProc = GET_M_GLOBAL(TransTable)[Format->formatter.i].DPrint;
(* printProc)(Data_Ptr, currentDStart, Stream, printer, Keep_With_Next);
break;
case PointerFMT:
StructPtr = REF(GENERIC_DATA_PTR, Data_Ptr, currentDStart);
if (StructPtr) {
printString(Stream, printer, "*", DEFAULT_KEEP);
Print_Structured_Data(Stream, printer,
CHOOSE_PTR_FORMAT(Format, parentFormat),
(CONST_GENERIC_DATA_PTR)StructPtr, 0,
(CONST_FORMAT_PTR)NULL, Keep_With_Next);
}
else
printString(Stream, printer, "NULL", Keep_With_Next);
break;
case StructFMT:
printString(Stream, printer, "{", DEFAULT_KEEP);
format_array = Format->formatter.a;
for (i=1;i<format_array[0].i;i++) {
if (printer->truncatedGlobal)
return;
else {
last_element_p = (i+1 == format_array[0].i);
next_keep = ((last_element_p) ? Keep_With_Next+1 : 1);
Print_Structured_Data(Stream, printer, format_array[i].f,
Data_Ptr+DStart, currentDStart-DStart,
Format, next_keep);
currentDStart += x_ipc_dataStructureSize(format_array[i].f);
currentDStart = x_ipc_alignField(Format, i, currentDStart);
if (last_element_p)
printString(Stream, printer, "}", Keep_With_Next);
else
printCommaSpace(Stream, printer);
}
}
break;
case FixedArrayFMT:
(void)printArrayData(Stream, printer, Format->formatter.a[1].f,
Data_Ptr, currentDStart,
Format->formatter.a, 2, Keep_With_Next, "[", "]");
break;
case VarArrayFMT:
ArrayPtr = REF(GENERIC_DATA_PTR, Data_Ptr, currentDStart);
format_array = Format->formatter.a;
if (ArrayPtr) {
fixed_format_array = fix_format_array(format_array,
parentFormat,
Data_Ptr, currentDStart);
(void)printArrayData(Stream, printer, format_array[1].f, ArrayPtr, 0,
fixed_format_array, 2, Keep_With_Next, "<", ">");
x_ipcFree((char *)fixed_format_array);
}
else
printString(Stream, printer, "NULL", Keep_With_Next);
break;
case NamedFMT:
Print_Structured_Data(Stream, printer,
x_ipc_fmtFind(Format->formatter.name),
Data_Ptr, currentDStart,
parentFormat, Keep_With_Next);
break;
case BadFormatFMT:
printString(Stream, printer, "Bad Format", Keep_With_Next);
case EnumFMT:
{ int32 eVal;
eVal = x_ipc_enumToInt(Format, Data_Ptr, ¤tDStart);
if (Format->formatter.a[0].i > 2 &&
/* enum value within range */
0 <= eVal && eVal <= ENUM_MAX_VAL(Format)) {
printString(Stream, printer,
Format->formatter.a[eVal+2].f->formatter.name,
Keep_With_Next);
} else {
printInt(Stream, printer, &eVal, Keep_With_Next);
}
break;
}
#ifndef TEST_CASE_COVERAGE
default:
X_IPC_MOD_ERROR1("Unknown Print_Structured_Data Type %d", Format->type);
break;
#endif
}
}
