int main(int argc, char **argv) {
usage(argc, argv); /* modes[0]: tid on/off, modes[1]: predicate on/off*/
MessageHead_t head;
void *body = NULL;
uint32_t len;
Journal_t** journal_array = NULL;
ValidationList_t* validation_list = validationListCreate();
int relation_count = 0;
while (1) {
if (read(0, &head, sizeof(head)) <= 0) {
exit(EXIT_FAILURE);
} // crude error handling, should never happen
if (head.messageLen > 0 ) {
body = malloc(head.messageLen * sizeof(char));
if (read(0, body, head.messageLen) <= 0) {
fprintf(stderr, "Error in Read Body");
exit(EXIT_FAILURE);
} // crude error handling, should never happen
len -= (sizeof(head) + head.messageLen);
}
// And interpret it
switch (head.type) {
case Done:
// validationListPrint(validation_list);
destroySchema(journal_array, relation_count);
validationListDestroy(validation_list);
free(modes);
return EXIT_SUCCESS;
case DefineSchema:
journal_array = processDefineSchema(body, &relation_count, modes);
if (body != NULL)
free(body);
break;
case Transaction:
processTransaction(body,journal_array);
if (body != NULL)
free(body);
break;
case ValidationQueries:
processValidationQueries(body,journal_array,validation_list);
break;
case Flush:
processFlush(body,journal_array,validation_list);
if(modes[3] != 1){
while(flushes != 0){
processFlush(last_flush,journal_array,validation_list);
}
}
if (body != NULL)
free(body);
break;
case Forget:
processForget(body,journal_array,relation_count);
if (body != NULL)
free(body);
break;
default:
exit(EXIT_FAILURE); // crude error handling, should never happen
}
}
return 0;
}
int main(int argc, char *argv[])
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
FILE *outfile = stdout; // Default is the standard output
char sourceFile[100];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
int argIndex = 1;
strcpy(sourceFile, "stdout");
if(argc >= 2)
{
if(strcmp(argv[argIndex], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strstr(argv[argIndex], "-schema") != NULL)
{
// Schema enabled encoding is requested.
// All the xsd files should be passed as comma-separated list
char* xsdList = argv[argIndex] + 7;
parseSchema(xsdList, &schema);
schemaPtr = &schema;
argIndex++;
}
}
if(argIndex < argc)
{
strcpy(sourceFile, argv[argIndex]);
outfile = fopen(sourceFile, "wb" );
if(!outfile)
{
fprintf(stderr, "Unable to open file %s", sourceFile);
return 1;
}
}
tmp_err_code = encode(schemaPtr, outfile, writeFileOutputStream);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
if(tmp_err_code != ERR_OK)
{
printf("\nError (code: %d) during encoding of: %s\n", tmp_err_code, sourceFile);
exit(1);
}
else
{
printf("\nSuccessful encoding in %s\n", sourceFile);
exit(1);
}
fclose(outfile);
}
int main(int argc, char *argv[])
{
FILE *infile = stdin;
char sourceFileName[500];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
EXIOptions ops;
EXIOptions* opsPtr = NULL;
boolean outOfBandOpts = FALSE;
unsigned char outFlag = OUT_EXI; // Default output option
unsigned int argIndex = 1;
errorCode tmp_err_code = EXIP_UNEXPECTED_ERROR;
strcpy(sourceFileName, "stdin");
makeDefaultOpts(&ops);
struct timespec start, stopGrammar, stopGrAndInstance;
if(argc > 1)
{
if(strcmp(argv[argIndex], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strcmp(argv[argIndex], "-exi") == 0)
{
outFlag = OUT_EXI;
if(argc == 2)
{
printfHelp();
return 0;
}
argIndex += 1;
}
else if(strcmp(argv[argIndex], "-xml") == 0)
{
outFlag = OUT_XML;
if(argc == 2)
{
printfHelp();
return 0;
}
argIndex += 1;
}
if(strstr(argv[argIndex], "-ops") != NULL)
{
char *mask = argv[argIndex] + 4;
outOfBandOpts = TRUE;
parseOpsMask(mask, &ops);
opsPtr = &ops;
argIndex += 1;
}
if(strstr(argv[argIndex], "-schema") != NULL)
{
char *xsdList = argv[argIndex] + 7;
if( clock_gettime( CLOCK_MONOTONIC, &start) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
parseSchema(xsdList, &schema);
if( clock_gettime( CLOCK_MONOTONIC, &stopGrammar) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
printf( "%ld ; ", ((long) (stopGrammar.tv_sec - start.tv_sec)*1000000000) + (long) (stopGrammar.tv_nsec - start.tv_nsec));
// printf( "SECONDS: %ld\n", (long) (stopGrammar.tv_sec - start.tv_sec));
// printf( "NANOSEC: %ld\n", (long) (stopGrammar.tv_nsec - start.tv_nsec));
schemaPtr = &schema;
argIndex += 1;
}
}
if(argIndex < argc)
{
strcpy(sourceFileName, argv[argIndex]);
infile = fopen(sourceFileName, "rb" );
if(!infile)
{
fprintf(stderr, "Unable to open file %s\n", sourceFileName);
exit(1);
}
}
tmp_err_code = decode(schemaPtr, outFlag, infile, outOfBandOpts, opsPtr, readFileInputStream);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
fclose(infile);
if( clock_gettime( CLOCK_MONOTONIC, &stopGrAndInstance) == -1 ) {
perror( "clock gettime" );
exit( EXIT_FAILURE );
}
printf( "%ld", ((long) (stopGrAndInstance.tv_sec - start.tv_sec)*1000000000) + (long) (stopGrAndInstance.tv_nsec - start.tv_nsec));
// printf( "SECONDS: %ld\n", (long) (stopGrAndInstance.tv_sec - start.tv_sec));
// printf( "NANOSEC: %ld\n", (long) (stopGrAndInstance.tv_nsec - start.tv_nsec));
if(tmp_err_code != EXIP_OK)
{
printf("\nError (code: %d) during parsing of the EXI stream: %s\n", tmp_err_code, sourceFileName);
return 1;
}
else
{
// printf("\nSuccessful parsing of the EXI stream: %s\n", sourceFileName);
return 0;
}
}
int main(int argc, char *argv[])
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
FILE *outfile;
char sourceFile[50];
EXIPSchema schema;
EXIPSchema* schemaPtr = NULL;
if(argc > 1)
{
if(strcmp(argv[1], "-help") == 0)
{
printfHelp();
return 0;
}
else if(strcmp(argv[1], "-schema") == 0)
{
FILE *schemaFile;
BinaryBuffer buffer[MAX_XSD_FILES_COUNT]; // up to 10 XSD files
char schemaFileName[50];
unsigned int schemaFilesCount = 0;
unsigned int i;
if(argc <= 3)
{
printfHelp();
return 0;
}
else
schemaFilesCount = argc - 3;
if(schemaFilesCount > MAX_XSD_FILES_COUNT)
{
fprintf(stderr, "Too many xsd files given as an input: %d", schemaFilesCount);
exit(1);
}
for(i = 0; i < schemaFilesCount; i++)
{
strcpy(schemaFileName, argv[2 + i]);
schemaFile = fopen(schemaFileName, "rb" );
if(!schemaFile)
{
fprintf(stderr, "Unable to open file %s", schemaFileName);
return 1;
}
else
{
//Get file length
fseek(schemaFile, 0, SEEK_END);
buffer[i].bufLen = ftell(schemaFile) + 1;
fseek(schemaFile, 0, SEEK_SET);
//Allocate memory
buffer[i].buf = (char *) malloc(buffer[i].bufLen);
if (!buffer[i].buf)
{
fprintf(stderr, "Memory allocation error!");
fclose(schemaFile);
return 1;
}
//Read file contents into buffer
fread(buffer[i].buf, buffer[i].bufLen, 1, schemaFile);
fclose(schemaFile);
buffer[i].bufContent = buffer[i].bufLen;
buffer[i].ioStrm.readWriteToStream = NULL;
buffer[i].ioStrm.stream = NULL;
}
}
tmp_err_code = generateSchemaInformedGrammars(buffer, schemaFilesCount, SCHEMA_FORMAT_XSD_EXI, &schema);
if(tmp_err_code != ERR_OK)
{
printf("\n Error occured: %d", tmp_err_code);
return 1;
}
schemaPtr = &schema;
for(i = 0; i < schemaFilesCount; i++)
{
free(buffer[i].buf);
}
}
strcpy(sourceFile, argv[argc - 1]);
outfile = fopen(sourceFile, "wb" );
if(!outfile)
{
fprintf(stderr, "Unable to open file %s", sourceFile);
return 1;
}
else
{
EXIStream testStrm;
String uri;
String ln;
QName qname = {&uri, &ln, NULL};
String chVal;
char buf[OUTPUT_BUFFER_SIZE];
BinaryBuffer buffer;
buffer.buf = buf;
buffer.bufLen = OUTPUT_BUFFER_SIZE;
buffer.bufContent = 0;
// Serialization steps:
// I: First initialize the header of the stream
serialize.initHeader(&testStrm);
// II: Set any options in the header, if different from the defaults
testStrm.header.has_cookie = TRUE;
testStrm.header.has_options = TRUE;
testStrm.header.opts.valueMaxLength = 300;
testStrm.header.opts.valuePartitionCapacity = 50;
SET_STRICT(testStrm.header.opts.enumOpt);
// III: Define an external stream for the output if any
buffer.ioStrm.readWriteToStream = writeFileOutputStream;
buffer.ioStrm.stream = outfile;
// IV: Initialize the stream
tmp_err_code = serialize.initStream(&testStrm, buffer, schemaPtr, SCHEMA_ID_ABSENT, NULL);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// V: Start building the stream step by step: header, document, element etc...
tmp_err_code += serialize.exiHeader(&testStrm);
tmp_err_code += serialize.startDocument(&testStrm);
qname.uri = &NS_STR;
qname.localName = &ELEM_MULT_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <MultipleXSDsTest>
qname.uri = &NS_STR;
qname.localName = &ELEM_ENCODE_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <EXIPEncoder>
// NOTE: attributes should come lexicographically sorted during serialization
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_BYTE_STR;
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_SMALL_INTEGER); // testByte="
tmp_err_code += serialize.intData(&testStrm, 55);
}
else
{
// schema-less mode
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // testByte="
tmp_err_code += asciiToString("55", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.localName = &ATTR_VERSION_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // version="
tmp_err_code += asciiToString("0.2", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("This is an example of serializing EXI streams using EXIP low level API", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </EXIPEncoder>
qname.uri = &NS_STR;
qname.localName = &ELEM_DESCR_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <description>
tmp_err_code += asciiToString("This is a test of processing XML schemes with multiple XSD files", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </description>
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_TEST_SETUP_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <testSetup>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_GOAL_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // goal="
tmp_err_code += asciiToString("Verify that the implementation works!", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += asciiToString("Simple test element with single attribute", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
tmp_err_code += serialize.endElement(&testStrm); // </testSetup>
qname.uri = &NS_STR;
qname.localName = &ELEM_TYPE_TEST_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <type-test>
if(schemaPtr != NULL)
{
// schema mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_INTEGER); // id="
tmp_err_code += serialize.intData(&testStrm, 1001);
}
else
{
// schema-less mode
qname.uri = &NS_EMPTY_STR;
qname.localName = &ATTR_ID_STR;
tmp_err_code += serialize.attribute(&testStrm, qname, VALUE_TYPE_STRING); // id="
tmp_err_code += asciiToString("1001", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
qname.uri = &NS_NESTED_STR;
qname.localName = &ELEM_BOOL_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <bool>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.booleanData(&testStrm, TRUE);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("true", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </bool>
tmp_err_code += serialize.endElement(&testStrm); // </type-test>
qname.uri = &NS_STR;
qname.localName = &ELEM_EXT_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <extendedTypeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BYTE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <byteTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.intData(&testStrm, 11);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("11", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </byteTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_DATE_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <dateTimeTest>
if(schemaPtr != NULL)
{
// schema mode
EXIPDateTime dt;
dt.presenceMask = 0;
dt.presenceMask = dt.presenceMask | YEAR_PRESENCE;
dt.presenceMask = dt.presenceMask | MON_PRESENCE;
dt.presenceMask = dt.presenceMask | MDAY_PRESENCE;
dt.presenceMask = dt.presenceMask | HOUR_PRESENCE;
dt.presenceMask = dt.presenceMask | MIN_PRESENCE;
dt.presenceMask = dt.presenceMask | SEC_PRESENCE;
dt.presenceMask = dt.presenceMask | FRACT_PRESENCE;
dt.dateTime.tm_year = 112; // 2012
dt.dateTime.tm_mon = 6; // July
dt.dateTime.tm_mday = 31;
dt.dateTime.tm_hour = 13;
dt.dateTime.tm_min = 33;
dt.dateTime.tm_sec = 55;
dt.fSecs.value = 839;
dt.fSecs.offset = 5;
tmp_err_code += serialize.dateTimeData(&testStrm, dt);
}
else
{
// schema-less mode
tmp_err_code += asciiToString("2012 Jul 31 13:33", &chVal, &testStrm.memList, FALSE);
tmp_err_code += serialize.stringData(&testStrm, chVal);
}
tmp_err_code += serialize.endElement(&testStrm); // </dateTimeTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_BIN_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <binaryTest>
if(schemaPtr != NULL)
{
// schema mode
tmp_err_code += serialize.binaryData(&testStrm, SOME_BINARY_DATA, 10);
}
else
{
// schema-less mode
tmp_err_code += serialize.stringData(&testStrm, SOME_BINARY_DATA_BASE64);
}
tmp_err_code += serialize.endElement(&testStrm); // </binaryTest>
qname.uri = &NS_EMPTY_STR;
qname.localName = &ELEM_ENUM_TYPES_STR;
tmp_err_code += serialize.startElement(&testStrm, qname); // <enumTest>
tmp_err_code += serialize.stringData(&testStrm, ENUM_DATA_4);
tmp_err_code += serialize.endElement(&testStrm); // </enumTest>
tmp_err_code += serialize.endElement(&testStrm); // </extendedTypeTest>
tmp_err_code += serialize.endElement(&testStrm); // </MultipleXSDsTest>
tmp_err_code += serialize.endDocument(&testStrm);
if(tmp_err_code != ERR_OK)
printError(tmp_err_code, &testStrm, outfile);
// VI: Free the memory allocated by the EXI stream object
tmp_err_code = serialize.closeEXIStream(&testStrm);
fclose(outfile);
if(schemaPtr != NULL)
destroySchema(schemaPtr);
}
}
else
{
printfHelp();
return 1;
}
return 0;
}
void XoFreeExiSchema() {
if (g_schemaPtr) {
destroySchema (g_schemaPtr);
g_schemaPtr = NULL;
}
}
