int main(int argc, char **argv) { bool verbose = false; #if 0 DOMParser::ValSchemes gValScheme = DOMParser::Val_Auto; bool gDoNamespaces = true; bool gDoSchema = true; bool gSchemaFullChecking = false; bool gDoCreate = false; #endif MFileOperations f; char path[1024]; f.expandPath(path, "MESA_TARGET", "runtime"); ::strcat(path, "/IHE-syslog-audit-message-4.xsd"); char* schemaDef = path; int detailLevel = 1; MString tmp; while (--argc > 0 && (*++argv)[0] == '-') { switch (*(argv[0] + 1)) { case 'l': argc--; argv++; if (argc < 1) usage(); tmp = *argv; detailLevel = tmp.intData(); break; case 's': argc--; argv++; if (argc < 1) usage(); schemaDef = *argv; break; case 'v': verbose = true; break; default: break; } } if (argc < 1) usage(); // Initialize the XML4C2 system try { XMLPlatformUtils::Initialize(); } catch (const XMLException& e) { cout << "Unable to initialize Xerces-c software" << DOMString(e.getMessage()) << endl; return 1; } DOMParser *parser = new DOMParser; parser->setValidationScheme(DOMParser::Val_Auto); parser->setDoNamespaces(true); parser->setDoSchema(true); parser->setValidationSchemaFullChecking(true); if (schemaDef != "") { parser->setExternalNoNamespaceSchemaLocation(schemaDef); } DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter(); parser->setErrorHandler(errReporter); parser->setCreateEntityReferenceNodes(false); parser->setToCreateXMLDeclTypeNode(true); bool errorFlag = false; try { parser->parse(*argv); int count = parser->getErrorCount(); if (count > 0) { errorFlag = true; return 1; } } catch (const XMLException& e) { cout << "Parsing error: " << DOMString(e.getMessage()) << endl; return 1; } catch (const DOM_DOMException& e) { cout << "DOM Error: " << e.code << endl; return 1; } catch (...) { cout << "Unspecified error" << endl; return 1; } DOM_Document doc = parser->getDocument(); unsigned int elementCount = doc.getElementsByTagName("*").getLength(); cout << "element count: " << elementCount << endl; return 0; }
int main (int argC, char *argV[]) { MemoryMonitor *staticMemMonitor = new MemoryMonitor(); // Initialize the XML4C system try { XMLPlatformUtils::Initialize(XMLUni::fgXercescDefaultLocale, 0, 0, staticMemMonitor); } catch (const XMLException& toCatch) { char *msg = XMLString::transcode(toCatch.getMessage()); XERCES_STD_QUALIFIER cerr << "Error during initialization! :\n" << msg << XERCES_STD_QUALIFIER endl; XMLString::release(&msg); return 1; } // Check command line and extract arguments. if (argC < 2) { usage(); return 1; } const char* xmlFile = 0; AbstractDOMParser::ValSchemes domBuilderValScheme = AbstractDOMParser::Val_Auto; bool doNamespaces = false; bool doSchema = false; bool schemaFullChecking = false; bool doList = false; bool errorOccurred = false; int numReps =1; int argInd; for (argInd = 1; argInd < argC; argInd++) { // Break out on first parm not starting with a dash if (argV[argInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[argInd], "-?")) { usage(); return 2; } else if (!strncmp(argV[argInd], "-v=", 3) || !strncmp(argV[argInd], "-V=", 3)) { const char* const parm = &argV[argInd][3]; if (!strcmp(parm, "never")) domBuilderValScheme = AbstractDOMParser::Val_Never; else if (!strcmp(parm, "auto")) domBuilderValScheme = AbstractDOMParser::Val_Auto; else if (!strcmp(parm, "always")) domBuilderValScheme = AbstractDOMParser::Val_Always; else { XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl; return 2; } } else if (!strcmp(argV[argInd], "-n") || !strcmp(argV[argInd], "-N")) { doNamespaces = true; } else if (!strcmp(argV[argInd], "-s") || !strcmp(argV[argInd], "-S")) { doSchema = true; } else if (!strcmp(argV[argInd], "-f") || !strcmp(argV[argInd], "-F")) { schemaFullChecking = true; } else if (!strcmp(argV[argInd], "-l") || !strcmp(argV[argInd], "-L")) { doList = true; } else if (!strncmp(argV[argInd], "-r=", 3) || !strncmp(argV[argInd], "-R=", 3)) { const char* const numStr = &argV[argInd][3]; XMLCh* numXStr = XMLString::transcode(numStr); numReps = XMLString::parseInt(numXStr); XMLString::release(&numXStr); } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[argInd] << "', ignoring it\n" << XERCES_STD_QUALIFIER endl; } } // // There should be only one and only one parameter left, and that // should be the file name. // if (argInd != argC - 1) { usage(); return 1; } // Instantiate the DOM domBuilder with its memory manager. MemoryMonitor *domBuilderMemMonitor = new MemoryMonitor(); static const XMLCh gLS[] = { chLatin_L, chLatin_S, chNull }; DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(gLS); DOMBuilder *domBuilder = ((DOMImplementationLS*)impl)->createDOMBuilder(DOMImplementationLS::MODE_SYNCHRONOUS, 0, domBuilderMemMonitor); DOMBuilderHandler domBuilderHandler; domBuilder->setErrorHandler(&domBuilderHandler); // Instantiate the SAX2 domBuilder with its memory manager. MemoryMonitor *sax2MemMonitor = new MemoryMonitor(); SAX2XMLReader *sax2parser = XMLReaderFactory::createXMLReader(sax2MemMonitor); SAXErrorHandler saxErrorHandler; sax2parser->setErrorHandler(&saxErrorHandler); // Instantiate the deprecated DOM parser with its memory manager. MemoryMonitor *depDOMMemMonitor = new MemoryMonitor(); DOMParser *depDOMParser = new (depDOMMemMonitor)DOMParser(0, depDOMMemMonitor); depDOMParser->setErrorHandler(&saxErrorHandler); // Instantiate the SAX 1 parser with its memory manager. MemoryMonitor *sax1MemMonitor = new MemoryMonitor(); SAXParser *saxParser = new (sax1MemMonitor) SAXParser(0, sax1MemMonitor); saxParser->setErrorHandler(&saxErrorHandler); // set features domBuilder->setFeature(XMLUni::fgDOMNamespaces, doNamespaces); sax2parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, doNamespaces); depDOMParser->setDoNamespaces(doNamespaces); saxParser->setDoNamespaces(doNamespaces); domBuilder->setFeature(XMLUni::fgXercesSchema, doSchema); sax2parser->setFeature(XMLUni::fgXercesSchema, doSchema); depDOMParser->setDoSchema(doSchema); saxParser->setDoSchema(doSchema); domBuilder->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking); sax2parser->setFeature(XMLUni::fgXercesSchemaFullChecking, schemaFullChecking); depDOMParser->setValidationSchemaFullChecking(schemaFullChecking); saxParser->setValidationSchemaFullChecking(schemaFullChecking); if (domBuilderValScheme == AbstractDOMParser::Val_Auto) { domBuilder->setFeature(XMLUni::fgDOMValidateIfSchema, true); sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true); sax2parser->setFeature(XMLUni::fgXercesDynamic, true); depDOMParser->setValidationScheme(DOMParser::Val_Auto); saxParser->setValidationScheme(SAXParser::Val_Auto); } else if (domBuilderValScheme == AbstractDOMParser::Val_Never) { domBuilder->setFeature(XMLUni::fgDOMValidation, false); sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, false); depDOMParser->setValidationScheme(DOMParser::Val_Never); saxParser->setValidationScheme(SAXParser::Val_Never); } else if (domBuilderValScheme == AbstractDOMParser::Val_Always) { domBuilder->setFeature(XMLUni::fgDOMValidation, true); sax2parser->setFeature(XMLUni::fgSAX2CoreValidation, true); sax2parser->setFeature(XMLUni::fgXercesDynamic, false); depDOMParser->setValidationScheme(DOMParser::Val_Always); saxParser->setValidationScheme(SAXParser::Val_Always); } // enable datatype normalization - default is off domBuilder->setFeature(XMLUni::fgDOMDatatypeNormalization, true); XERCES_STD_QUALIFIER ifstream fin; bool more = true; // the input is a list file if (doList) fin.open(argV[argInd]); if (fin.fail()) { XERCES_STD_QUALIFIER cerr <<"Cannot open the list file: " << argV[argInd] << XERCES_STD_QUALIFIER endl; return 2; } while (more) { char fURI[1000]; //initialize the array to zeros memset(fURI,0,sizeof(fURI)); if (doList) { if (! fin.eof() ) { fin.getline (fURI, sizeof(fURI)); if (!*fURI) continue; else { xmlFile = fURI; XERCES_STD_QUALIFIER cerr << "==Parsing== " << xmlFile << XERCES_STD_QUALIFIER endl; } } else break; } else { xmlFile = argV[argInd]; more = false; } // parse numReps times (in case we need it for some reason) for (int i=0; i<numReps; i++) { XERCES_CPP_NAMESPACE_QUALIFIER DOMDocument *doc = 0; try { // reset document pool domBuilder->resetDocumentPool(); doc = domBuilder->parseURI(xmlFile); sax2parser->parse(xmlFile); depDOMParser->parse(xmlFile); saxParser->parse(xmlFile); } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException during parsing: '" << xmlFile << "'\n" << XERCES_STD_QUALIFIER endl;; continue; } catch (const XMLException& toCatch) { char *msg = XMLString::transcode(toCatch.getMessage()); XERCES_STD_QUALIFIER cerr << "\nError during parsing: '" << xmlFile << "'\n" << "Exception message is: \n" << msg << "\n" << XERCES_STD_QUALIFIER endl; XMLString::release(&msg); continue; } catch (const DOMException& toCatch) { const unsigned int maxChars = 2047; XMLCh errText[maxChars + 1]; XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n" << "DOMException code is: " << toCatch.code << XERCES_STD_QUALIFIER endl; if (DOMImplementation::loadDOMExceptionMsg(toCatch.code, errText, maxChars)) { char * msg = XMLString::transcode(errText); XERCES_STD_QUALIFIER cerr << "Message is: " << msg << XERCES_STD_QUALIFIER endl; continue; } } catch (...) { XERCES_STD_QUALIFIER cerr << "\nUnexpected exception during parsing: '" << xmlFile << "'\n"; continue; } } } // // Delete the domBuilder itself. Must be done prior to calling Terminate, below. // domBuilder->release(); delete sax2parser; delete depDOMParser; delete saxParser; XERCES_STD_QUALIFIER cout << "At destruction, domBuilderMemMonitor has " << domBuilderMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl; XERCES_STD_QUALIFIER cout << "At destruction, sax2MemMonitor has " << sax2MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl; XERCES_STD_QUALIFIER cout << "At destruction, depDOMMemMonitor has " << depDOMMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl; XERCES_STD_QUALIFIER cout << "At destruction, sax1MemMonitor has " << sax1MemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl; delete domBuilderMemMonitor; delete sax2MemMonitor; delete depDOMMemMonitor; delete sax1MemMonitor; XMLPlatformUtils::Terminate(); XERCES_STD_QUALIFIER cout << "At destruction, staticMemMonitor has " << staticMemMonitor->getTotalMemory() << " bytes." << XERCES_STD_QUALIFIER endl; delete staticMemMonitor; return 0; }