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; } }