static errorCode sample_intData(Integer int_val, void* app_data) { appData* appD = (appData*) app_data; /* char tmp_buf[30]; */ if(appD->expectAttributeData) { asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE); /* sprintf(tmp_buf, "%lld", int_val); printf("%s", tmp_buf); printf("\"\n"); */ appD->expectAttributeData = 0; } else { asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE); /* sprintf(tmp_buf, "%lld", int_val); printf("%s", tmp_buf); printf("\n"); */ } return EXIP_OK; }
static errorCode sample_floatData(Float fl_val, void* app_data) { appData* appD = (appData*) app_data; /* char tmp_buf[30]; */ if(appD->expectAttributeData) { asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE); /* sprintf(tmp_buf, "%lldE%d", fl_val.mantissa, fl_val.exponent); printf("%s", tmp_buf); printf("\"\n"); */ appD->expectAttributeData = 0; } else { asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE); /* printf("%3d CH ", appD->eventCount); sprintf(tmp_buf, "%lldE%d", fl_val.mantissa, fl_val.exponent); printf("%s", tmp_buf); printf("\n"); */ } return EXIP_OK; }
/** * @brief Create a File Writer (libxml2 compatibility function) * @param uri Filename * @param compression Unused * @return A xmlTextWriterPtr object */ static xmlTextWriterPtr xmlNewTextWriterFilename(const char *uri, int compression, char *schemaID) { EXIStream *stream; xmlBufferPtr buf = xmlBufferCreate(); FILE *outfile = fopen(uri, "wb" ); if(!outfile) return NULL; stream = calloc(sizeof(EXIStream), 1); // I: First initialize the header of the stream serialize.initHeader(stream); // II: Set any options in the header, if different from the defaults //stream->header.has_cookie = TRUE; stream->header.has_options = TRUE; //stream->header.opts.valueMaxLength = 300; //stream->header.opts.valuePartitionCapacity = 50; // SET_STRICT(stream->header.opts.enumOpt); SET_PRESERVED(stream->header.opts.preserve, PRESERVE_PREFIXES); // SET_ALIGNMENT(stream->header.opts.enumOpt, BYTE_ALIGNMENT); // III: Define an external stream for the output if any buf->ioStrm.readWriteToStream = writeFileOutputStream; buf->ioStrm.stream = outfile; // IV: Initialize the stream #if EXIP_VERSION==276 if (schemaID && *schemaID) { XoExiLoadSchema (schemaID); String s; asciiToString(schemaID, &s, &stream->memList, FALSE); serialize.initStream(stream, *buf, g_schemaPtr, SCHEMA_ID_SET, &s); } else { serialize.initStream(stream, *buf, g_schemaPtr, SCHEMA_ID_ABSENT, NULL); } #endif #if EXIP_VERSION>=289 if (schemaID && *schemaID) { XoExiLoadSchema (schemaID); asciiToString(schemaID, &stream->header.opts.schemaID, &stream->memList, FALSE); stream->header.opts.schemaIDMode = SCHEMA_ID_SET; } else { stream->header.opts.schemaIDMode = SCHEMA_ID_ABSENT; } serialize.initStream(stream, *buf, g_schemaPtr); #endif // V: Start building the stream step by step: header, document, element etc... serialize.exiHeader(stream); return (xmlTextWriterPtr)stream; }
void serializeXSITYPE(EXIStream *strm, char *value) { char s_uri[100], s_ln[100]; String uri; String ln; QName qxsi = {&uri,&ln}; PRINT ("serialize.qnameData %s\n", value); cutQName (value, s_uri, s_ln); asciiToString(s_uri, &uri, &strm->memList, FALSE); asciiToString(s_ln, &ln, &strm->memList, FALSE); serialize.qnameData(strm, qxsi); }
static errorCode sample_endElement(void* app_data) { appData* appD = (appData*) app_data; asciiToString("EE", &appD->eventCode, &appD->allocList, TRUE); return EXIP_OK; }
static errorCode sample_decimalData(Decimal value, void* app_data) { appData* appD = (appData*) app_data; if(appD->expectAttributeData) { asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE); /* printf("%.1f\"\n", (double) value); */ appD->expectAttributeData = 0; } else { asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE); } return EXIP_OK; }
static errorCode sample_startElement(QName qname, void* app_data) { appData* appD = (appData*) app_data; asciiToString("SE", &appD->eventCode, &appD->allocList, TRUE); cloneStringManaged(qname.uri, &appD->uri, &appD->allocList); cloneStringManaged(qname.localName, &appD->localName, &appD->allocList); return EXIP_OK; }
static errorCode sample_stringData(const String value, void* app_data) { appData* appD = (appData*) app_data; if(appD->expectAttributeData) { asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE); /* printString(&value); printf("\"\n"); */ appD->expectAttributeData = 0; } else { asciiToString("CH", &appD->eventCode, &appD->allocList, TRUE); /* printString(&value); printf("\n"); */ } return EXIP_OK; }
static errorCode sample_attribute(QName qname, void* app_data) { appData* appD = (appData*) app_data; asciiToString("AT", &appD->eventCode, &appD->allocList, TRUE); /* printString(qname.uri); printf(" "); printString(qname.localName); printf("=\""); */ appD->expectAttributeData = 1; return EXIP_OK; }
/** * @brief Writes a string as an element's content (libxml2 compatibility function) * @param writer An EXIStream * @param content String * @return 0 if success, -1 if error */ static int xmlTextWriterWriteString(xmlTextWriterPtr writer, const xmlChar *content) { int ret = 0; PRINT ("CH [%s] (%d)\n", (char *)content, strlen((char *)content)); if (g_schemaPtr) { String uri = {NULL,0}; String localName = {NULL,0}; QName qname = {&uri, &localName, NULL }; ret = ExiSerialize(writer, qname, (char *)content, FALSE, currentContext()->valueType); } else { String chVal; ret += asciiToString((char *)content, &chVal, &writer->memList, FALSE); PRINT ("serialize.stringData (%s)\n", (char *)content); ret += serialize.stringData(writer, chVal); } if (ret) return -1; return 0; }
void loadEffectsFromHost(void) { initializeEffects(); uartInit(); char received[500]; for (int i = 0; i < 500; ++i) { received[i] = '\0'; } int write = 0; bool done = _FALSE; while ((!done) && (write < 500)) { while (!uartIsDataReady()) ; received[write] = uartRead(); if (received[write] == ESCAPE_MESSAGE_END) { done = _TRUE; } write++; } if (write > 500) { error("Received message is over 500 characters and contains no ESCAPE_MESSAGE_END character."); } int read = 0; int effect_idx = 0; while ((read < write) && (received[read] != ESCAPE_MESSAGE_END)) { // First comes the effect's name effects[effect_idx].in_use = _TRUE; asciiToString(received, &read, effects[effect_idx].name, EFFECT_NAME_LENGTH); // We're now at the parameters int param_idx = 0; while (received[read] != ESCAPE_EFFECT_END) { // Parameter name asciiToString(received, &read, effects[effect_idx].params[param_idx].name, PARAM_NAME_LENGTH); // Parameter values, in order: min - regular - max effects[effect_idx].params[param_idx].min = asciiToInt2d(received, &read); effects[effect_idx].params[param_idx].regular = asciiToInt2d(received, &read); effects[effect_idx].params[param_idx].max = asciiToInt2d(received, &read); // Each parameters starts set at the regular value effects[effect_idx].params[param_idx].current = effects[effect_idx].params[param_idx].regular; effects[effect_idx].params[param_idx].in_use = _TRUE; param_idx++; // We're now at the next parameter (or next effect, or message ending) } effect_idx++; read++; // Advance to the next effect (or message ending) } numLoadedEffects = effect_idx; }
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; }
/** * @brief Writes an attribute (libxml2 compatibility function) * @param[in] writer An EXIStream * @param[in] name Attribute name * @param[in] value Attribute value * @return 0 if success, -1 if error */ static int xmlTextWriterWriteAttribute(xmlTextWriterPtr writer, char*name, char *value) { String uri = {NULL,0}; String localName = {NULL,0}; QName qname = {&uri, &localName, NULL }; String chVal; int ret = 0; int type = 0; PRINT ("AT %s=%s\n", name, value); if (strcmp(name,"xsi:type") == 0) { type = VALUE_TYPE_QNAME_CLASS; } else if (g_schemaPtr && strstr(name, "xmlns")) return 0; name = strdup(name); char *pfx; char *lname = strchr(name, ':'); if (lname) { pfx = name; *lname++ = 0; pfx = getNamespaceByPrefix(pfx); uri.str = pfx; uri.length = strlen(pfx); } else { //pfx = ""; /* XXX uri.str = g_NsDefault; uri.length = strlen(g_NsDefault); */ lname = name; } localName.str = lname; localName.length = strlen(lname); if (g_schemaPtr) { if (!strcmp(lname, "xmlns")) { strcpy (g_NsDefault, value); /* String ns = { value, strlen(value) }; errorCode err = serialize.namespaceDeclaration(writer, ns, localName, 0); printf ("serialize.namespaceDeclaration(%s , %s)\n", value, lname); */ //XoAddNameSpace(lname, value); } else { ret = ExiSerialize(writer, qname, value, TRUE, type); } } else { EXITypeClass valueType; PRINT ("serialize.attribute "); writeQName(qname); PRINT ("\n"); ret += serialize.attribute(writer, qname, TRUE, &valueType); if (ret) { free(name);return -1; } // xsi:type if (type == VALUE_TYPE_QNAME_CLASS) { serializeXSITYPE(writer, value); } else { ret += asciiToString((char *)value, &chVal, &writer->memList, FALSE); PRINT ("serialize.stringData (%s)\n", value); ret += serialize.stringData(writer, chVal); } } free (name); if (ret) return -1; return 0; }
END_TEST START_TEST (test_noLearning02) { EXIStream testStrm; Parser testParser; String uri; String ln; QName qname= {&uri, &ln}; String chVal; char buf[OUTPUT_BUFFER_SIZE]; errorCode tmp_err_code = EXIP_UNEXPECTED_ERROR; BinaryBuffer buffer; EXITypeClass valueType; buffer.buf = buf; buffer.bufContent = 0; buffer.bufLen = OUTPUT_BUFFER_SIZE; buffer.ioStrm.readWriteToStream = NULL; buffer.ioStrm.stream = NULL; // 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_options = TRUE; testStrm.header.opts.schemaIDMode = SCHEMA_ID_EMPTY; // III: Define an external stream for the output if any // IV: Initialize the stream tmp_err_code = serialize.initStream(&testStrm, buffer, NULL); fail_unless (tmp_err_code == EXIP_OK, "initStream returns an error code %d", tmp_err_code); // V: Start building the stream step by step: header, document, element etc... tmp_err_code = serialize.exiHeader(&testStrm); fail_unless (tmp_err_code == EXIP_OK, "serialize.exiHeader returns an error code %d", tmp_err_code); tmp_err_code = serialize.startDocument(&testStrm); fail_unless (tmp_err_code == EXIP_OK, "serialize.startDocument returns an error code %d", tmp_err_code); getEmptyString(&uri); tmp_err_code += asciiToString("root", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("a", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("bla", &chVal, &testStrm.memList, FALSE); tmp_err_code += serialize.stringData(&testStrm, chVal); fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += asciiToString("b", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("23", &chVal, &testStrm.memList, FALSE); tmp_err_code += serialize.stringData(&testStrm, chVal); fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += asciiToString("a", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("bla", &chVal, &testStrm.memList, FALSE); tmp_err_code += serialize.stringData(&testStrm, chVal); fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += asciiToString("c", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("b", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.startElement(&testStrm, qname, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.startElement returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("http://www.w3.org/2001/XMLSchema-instance", &uri, &testStrm.memList, FALSE); tmp_err_code += asciiToString("type", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.attribute(&testStrm, qname, TRUE, &valueType); fail_unless (tmp_err_code == EXIP_OK, "serialize.attribute returns an error code %d", tmp_err_code); tmp_err_code += asciiToString("http://www.w3.org/2001/XMLSchema", &uri, &testStrm.memList, FALSE); tmp_err_code += asciiToString("integer", &ln, &testStrm.memList, FALSE); tmp_err_code += serialize.qnameData(&testStrm, qname); fail_unless (tmp_err_code == EXIP_OK, "serialize.qnameData returns an error code %d", tmp_err_code); tmp_err_code += serialize.intData(&testStrm, 66); fail_unless (tmp_err_code == EXIP_OK, "serialize.stringData returns an error code %d", tmp_err_code); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += serialize.endElement(&testStrm); tmp_err_code += serialize.endDocument(&testStrm); if(tmp_err_code != EXIP_OK) fail_unless (tmp_err_code == EXIP_OK, "serialization ended with error code %d", tmp_err_code); // V: Free the memory allocated by the EXI stream object tmp_err_code = serialize.closeEXIStream(&testStrm); fail_unless (tmp_err_code == EXIP_OK, "serialize.closeEXIStream ended with error code %d", tmp_err_code); buffer.bufContent = OUTPUT_BUFFER_SIZE; // Parsing steps: // I: First, define an external stream for the input to the parser if any // II: Second, initialize the parser object tmp_err_code = initParser(&testParser, buffer, NULL); fail_unless (tmp_err_code == EXIP_OK, "initParser returns an error code %d", tmp_err_code); // III: Initialize the parsing data and hook the callback handlers to the parser object // IV: Parse the header of the stream tmp_err_code = parseHeader(&testParser, TRUE); fail_unless (tmp_err_code == EXIP_OK, "parsing the header returns an error code %d", tmp_err_code); tmp_err_code = setSchema(&testParser, NULL); fail_unless (tmp_err_code == EXIP_OK, "setSchema() returns an error code %d", tmp_err_code); // V: Parse the body of the EXI stream while(tmp_err_code == EXIP_OK) { tmp_err_code = parseNext(&testParser); } // VI: Free the memory allocated by the parser object destroyParser(&testParser); fail_unless (tmp_err_code == EXIP_PARSING_COMPLETE, "Error during parsing of the EXI body %d", tmp_err_code); }