errorCode initParser(Parser* parser, BinaryBuffer buffer, EXIPSchema* schema, void* app_data)
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
tmp_err_code = initAllocList(&parser->strm.memList);
if(tmp_err_code != ERR_OK)
return tmp_err_code;
parser->strm.buffer = buffer;
parser->strm.context.bitPointer = 0;
parser->strm.context.bufferIndx = 0;
parser->strm.context.currNonTermID = GR_DOCUMENT;
parser->strm.context.currElem.lnId = 0;
parser->strm.context.currElem.uriId = 0;
parser->strm.context.currAttr.lnId = 0;
parser->strm.context.currAttr.uriId = 0;
parser->strm.context.expectATData = 0;
parser->strm.context.attrTypeId = INDEX_MAX;
parser->strm.gStack = NULL;
parser->strm.valueTable.value = NULL;
parser->strm.valueTable.hashTbl = NULL;
parser->app_data = app_data;
parser->strm.schema = schema;
makeDefaultOpts(&parser->strm.header.opts);
initContentHandler(&parser->handler);
return ERR_OK;
}
END_TEST
START_TEST (test_pushGrammar)
{
errorCode err = EXIP_UNEXPECTED_ERROR;
EXIGrammarStack* testGrStack = NULL;
EXIStream strm;
EXIGrammar testElementGrammar;
EXIGrammar testElementGrammar1;
QNameID emptyQnameID = {URI_MAX, LN_MAX};
makeDefaultOpts(&strm.header.opts);
initAllocList(&strm.memList);
#if BUILD_IN_GRAMMARS_USE
err = createBuiltInElementGrammar(&testElementGrammar1, &strm);
fail_if(err != EXIP_OK);
err = createBuiltInElementGrammar(&testElementGrammar, &strm);
fail_if(err != EXIP_OK);
#endif
err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar1);
fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
fail_if(testGrStack->nextInStack != NULL);
err = pushGrammar(&testGrStack, emptyQnameID, &testElementGrammar);
fail_unless (err == EXIP_OK, "pushGrammar returns error code %d", err);
fail_if(testGrStack->nextInStack == NULL);
fail_if(testGrStack->nextInStack->grammar != &testElementGrammar1);
freeAllocList(&strm.memList);
}
END_TEST
#if BUILD_IN_GRAMMARS_USE
START_TEST (test_createBuiltInElementGrammar)
{
errorCode err = EXIP_UNEXPECTED_ERROR;
EXIGrammar testElementGrammar;
EXIStream strm;
makeDefaultOpts(&strm.header.opts);
initAllocList(&strm.memList);
err = createBuiltInElementGrammar(&testElementGrammar, &strm);
fail_unless (err == EXIP_OK, "createBuildInElementGrammar returns error code %d", err);
}
errorCode decodeHeader(EXIStream* strm, boolean outOfBandOpts)
{
errorCode tmp_err_code = UNEXPECTED_ERROR;
unsigned int bits_val = 0;
boolean boolVal = FALSE;
DEBUG_MSG(INFO, DEBUG_CONTENT_IO, (">Start EXI header decoding\n"));
TRY(readBits(strm, 2, &bits_val));
if(bits_val == 2) // The header Distinguishing Bits i.e. no EXI Cookie
{
strm->header.has_cookie = 0;
DEBUG_MSG(INFO, DEBUG_CONTENT_IO, (">No EXI cookie detected\n"));
}
else if(bits_val == 0)// ASCII code for $ = 00100100 (36)
{
TRY(readBits(strm, 6, &bits_val));
if(bits_val != 36)
return INVALID_EXI_HEADER;
TRY(readBits(strm, 8, &bits_val));
if(bits_val != 69) // ASCII code for E = 01000101 (69)
return INVALID_EXI_HEADER;
TRY(readBits(strm, 8, &bits_val));
if(bits_val != 88) // ASCII code for X = 01011000 (88)
return INVALID_EXI_HEADER;
TRY(readBits(strm, 8, &bits_val));
if(bits_val != 73) // ASCII code for I = 01001001 (73)
return INVALID_EXI_HEADER;
strm->header.has_cookie = 1;
DEBUG_MSG(INFO, DEBUG_CONTENT_IO, (">EXI cookie detected\n"));
TRY(readBits(strm, 2, &bits_val));
if(bits_val != 2) // The header Distinguishing Bits are required
return INVALID_EXI_HEADER;
}
else
{
return INVALID_EXI_HEADER;
}
// Read the Presence Bit for EXI Options
TRY(readNextBit(strm, &boolVal));
if(boolVal == TRUE) // There are EXI options
{
strm->header.has_options = TRUE;
// validation checks. If the options are included then
// they cannot be set by an out-of-band mechanism.
// If out-of-band options are set -
// rise a warning and overwrite them.
// Only the options from the header will be used
if(outOfBandOpts == TRUE)
{
DEBUG_MSG(WARNING, DEBUG_CONTENT_IO, (">Ignored out-of-band set EXI options\n"));
makeDefaultOpts(&strm->header.opts);
}
}
else // Out-of-band set EXI options
{
DEBUG_MSG(INFO, DEBUG_CONTENT_IO, (">No EXI options field in the header\n"));
strm->header.has_options = FALSE;
if(outOfBandOpts == FALSE)
{
DEBUG_MSG(ERROR, DEBUG_CONTENT_IO, (">No EXI options in the header and no out-of-band options specified. \n"));
return HEADER_OPTIONS_MISMATCH;
}
}
// Read the Version type
TRY(readNextBit(strm, &boolVal));
strm->header.is_preview_version = boolVal;
strm->header.version_number = 1;
do
{
TRY(readBits(strm, 4, &bits_val));
strm->header.version_number += bits_val;
if(bits_val < 15)
break;
} while(1);
DEBUG_MSG(INFO, DEBUG_CONTENT_IO, (">EXI version: %d\n", strm->header.version_number));
if(strm->header.has_options == 1)
{
Parser optionsParser;
struct ops_AppData appD;
TRY(initParser(&optionsParser, strm->buffer, &appD));
optionsParser.strm.context.bitPointer = strm->context.bitPointer;
optionsParser.strm.context.bufferIndx = strm->context.bufferIndx;
optionsParser.strm.gStack = NULL;
makeDefaultOpts(&optionsParser.strm.header.opts);
SET_STRICT(optionsParser.strm.header.opts.enumOpt);
optionsParser.handler.fatalError = ops_fatalError;
optionsParser.handler.error = ops_fatalError;
optionsParser.handler.startDocument = ops_startDocument;
optionsParser.handler.endDocument = ops_endDocument;
optionsParser.handler.startElement = ops_startElement;
optionsParser.handler.attribute = ops_attribute;
optionsParser.handler.stringData = ops_stringData;
optionsParser.handler.endElement = ops_endElement;
optionsParser.handler.intData = ops_intData;
optionsParser.handler.booleanData = ops_boolData;
appD.o_strm = &optionsParser.strm;
appD.parsed_ops = &strm->header.opts;
appD.prevElementLnID = 0;
appD.prevElementUriID = 0;
appD.permanentAllocList = &strm->memList;
TRY_CATCH(setSchema(&optionsParser, (EXIPSchema*) &ops_schema), destroyParser(&optionsParser));
TRY_CATCH(createValueTable(&optionsParser.strm.valueTable), destroyParser(&optionsParser));
while(tmp_err_code == ERR_OK)
{
tmp_err_code = parseNext(&optionsParser);
}
destroyParser(&optionsParser);
if(tmp_err_code != PARSING_COMPLETE)
return tmp_err_code;
strm->buffer.bufContent = optionsParser.strm.buffer.bufContent;
strm->context.bitPointer = optionsParser.strm.context.bitPointer;
strm->context.bufferIndx = optionsParser.strm.context.bufferIndx;
if(WITH_COMPRESSION(strm->header.opts.enumOpt) ||
GET_ALIGNMENT(strm->header.opts.enumOpt) != BIT_PACKED)
{
// Padding bits
if(strm->context.bitPointer != 0)
{
strm->context.bitPointer = 0;
strm->context.bufferIndx += 1;
}
}
}
return checkOptionValues(&strm->header.opts);
}
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;
}
}
