// --------------------------------------------------------------------------- // // main // // --------------------------------------------------------------------------- int main(int argC, char* argV[]) { int retval = 0; // Initialize the XML4C2 system try { XMLPlatformUtils::Initialize(); } catch(const XMLException &toCatch) { XERCES_STD_QUALIFIER cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << StrX(toCatch.getMessage()) << XERCES_STD_QUALIFIER endl; return 1; } // Check command line and extract arguments. if (argC < 2) { usage(); XMLPlatformUtils::Terminate(); return 1; } // See if non validating dom parser configuration is requested. int parmInd; for (parmInd = 1; parmInd < argC; parmInd++) { // Break out on first parm not starting with a dash if (argV[parmInd][0] != '-') break; // Watch for special case help request if (!strcmp(argV[parmInd], "-?")) { usage(); XMLPlatformUtils::Terminate(); return 2; } else if (!strncmp(argV[parmInd], "-v=", 3) || !strncmp(argV[parmInd], "-V=", 3)) { const char* const parm = &argV[parmInd][3]; if (!strcmp(parm, "never")) gValScheme = XercesDOMParser::Val_Never; else if (!strcmp(parm, "auto")) gValScheme = XercesDOMParser::Val_Auto; else if (!strcmp(parm, "always")) gValScheme = XercesDOMParser::Val_Always; else { XERCES_STD_QUALIFIER cerr << "Unknown -v= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strcmp(argV[parmInd], "-n") || !strcmp(argV[parmInd], "-N")) { gDoNamespaces = true; } else if (!strcmp(argV[parmInd], "-s") || !strcmp(argV[parmInd], "-S")) { gDoSchema = true; } else if (!strcmp(argV[parmInd], "-f") || !strcmp(argV[parmInd], "-F")) { gSchemaFullChecking = true; } else if (!strcmp(argV[parmInd], "-e") || !strcmp(argV[parmInd], "-E")) { gDoCreate = true; } else if (!strncmp(argV[parmInd], "-wenc=", 6)) { // Get out the encoding name gOutputEncoding = XMLString::transcode( &(argV[parmInd][6]) ); } else if (!strncmp(argV[parmInd], "-wfile=", 7)) { goutputfile = &(argV[parmInd][7]); } else if (!strncmp(argV[parmInd], "-wddc=", 6)) { const char* const parm = &argV[parmInd][6]; if (!strcmp(parm, "on")) gDiscardDefaultContent = true; else if (!strcmp(parm, "off")) gDiscardDefaultContent = false; else { XERCES_STD_QUALIFIER cerr << "Unknown -wddc= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strncmp(argV[parmInd], "-wscs=", 6)) { const char* const parm = &argV[parmInd][6]; if (!strcmp(parm, "on")) gSplitCdataSections = true; else if (!strcmp(parm, "off")) gSplitCdataSections = false; else { XERCES_STD_QUALIFIER cerr << "Unknown -wscs= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strncmp(argV[parmInd], "-wflt=", 6)) { const char* const parm = &argV[parmInd][6]; if (!strcmp(parm, "on")) gUseFilter = true; else if (!strcmp(parm, "off")) gUseFilter = false; else { XERCES_STD_QUALIFIER cerr << "Unknown -wflt= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strncmp(argV[parmInd], "-wfpp=", 6)) { const char* const parm = &argV[parmInd][6]; if (!strcmp(parm, "on")) gFormatPrettyPrint = true; else if (!strcmp(parm, "off")) gFormatPrettyPrint = false; else { XERCES_STD_QUALIFIER cerr << "Unknown -wfpp= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strncmp(argV[parmInd], "-wbom=", 6)) { const char* const parm = &argV[parmInd][6]; if (!strcmp(parm, "on")) gWriteBOM = true; else if (!strcmp(parm, "off")) gWriteBOM = false; else { XERCES_STD_QUALIFIER cerr << "Unknown -wbom= value: " << parm << XERCES_STD_QUALIFIER endl; XMLPlatformUtils::Terminate(); return 2; } } else if (!strncmp(argV[parmInd], "-xpath=", 7)) { gXPathExpression = &(argV[parmInd][7]); } else { XERCES_STD_QUALIFIER cerr << "Unknown option '" << argV[parmInd] << "', ignoring it.\n" << XERCES_STD_QUALIFIER endl; } } // // And now we have to have only one parameter left and it must be // the file name. // if (parmInd + 1 != argC) { usage(); XMLPlatformUtils::Terminate(); return 1; } gXmlFile = argV[parmInd]; // // Create our parser, then attach an error handler to the parser. // The parser will call back to methods of the ErrorHandler if it // discovers errors during the course of parsing the XML document. // XercesDOMParser *parser = new XercesDOMParser; parser->setValidationScheme(gValScheme); parser->setDoNamespaces(gDoNamespaces); parser->setDoSchema(gDoSchema); parser->setValidationSchemaFullChecking(gSchemaFullChecking); parser->setCreateEntityReferenceNodes(gDoCreate); DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter(); parser->setErrorHandler(errReporter); // // Parse the XML file, catching any XML exceptions that might propogate // out of it. // bool errorsOccured = false; try { parser->parse(gXmlFile); } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; errorsOccured = true; } catch (const XMLException& e) { XERCES_STD_QUALIFIER cerr << "An error occurred during parsing\n Message: " << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; errorsOccured = true; } catch (const DOMException& e) { const unsigned int maxChars = 2047; XMLCh errText[maxChars + 1]; XERCES_STD_QUALIFIER cerr << "\nDOM Error during parsing: '" << gXmlFile << "'\n" << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl; if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars)) XERCES_STD_QUALIFIER cerr << "Message is: " << StrX(errText) << XERCES_STD_QUALIFIER endl; errorsOccured = true; } catch (...) { XERCES_STD_QUALIFIER cerr << "An error occurred during parsing\n " << XERCES_STD_QUALIFIER endl; errorsOccured = true; } // If the parse was successful, output the document data from the DOM tree if (!errorsOccured && !errReporter->getSawErrors()) { DOMPrintFilter *myFilter = 0; try { // get a serializer, an instance of DOMLSSerializer XMLCh tempStr[3] = {chLatin_L, chLatin_S, chNull}; DOMImplementation *impl = DOMImplementationRegistry::getDOMImplementation(tempStr); DOMLSSerializer *theSerializer = ((DOMImplementationLS*)impl)->createLSSerializer(); DOMLSOutput *theOutputDesc = ((DOMImplementationLS*)impl)->createLSOutput(); // set user specified output encoding theOutputDesc->setEncoding(gOutputEncoding); // plug in user's own filter if (gUseFilter) { // even we say to show attribute, but the DOMLSSerializer // will not show attribute nodes to the filter as // the specs explicitly says that DOMLSSerializer shall // NOT show attributes to DOMLSSerializerFilter. // // so DOMNodeFilter::SHOW_ATTRIBUTE has no effect. // same DOMNodeFilter::SHOW_DOCUMENT_TYPE, no effect. // myFilter = new DOMPrintFilter(DOMNodeFilter::SHOW_ELEMENT | DOMNodeFilter::SHOW_ATTRIBUTE | DOMNodeFilter::SHOW_DOCUMENT_TYPE); theSerializer->setFilter(myFilter); } // plug in user's own error handler DOMErrorHandler *myErrorHandler = new DOMPrintErrorHandler(); DOMConfiguration* serializerConfig=theSerializer->getDomConfig(); serializerConfig->setParameter(XMLUni::fgDOMErrorHandler, myErrorHandler); // set feature if the serializer supports the feature/mode if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections)) serializerConfig->setParameter(XMLUni::fgDOMWRTSplitCdataSections, gSplitCdataSections); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent)) serializerConfig->setParameter(XMLUni::fgDOMWRTDiscardDefaultContent, gDiscardDefaultContent); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint)) serializerConfig->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, gFormatPrettyPrint); if (serializerConfig->canSetParameter(XMLUni::fgDOMWRTBOM, gWriteBOM)) serializerConfig->setParameter(XMLUni::fgDOMWRTBOM, gWriteBOM); // // Plug in a format target to receive the resultant // XML stream from the serializer. // // StdOutFormatTarget prints the resultant XML stream // to stdout once it receives any thing from the serializer. // XMLFormatTarget *myFormTarget; if (goutputfile) myFormTarget=new LocalFileFormatTarget(goutputfile); else myFormTarget=new StdOutFormatTarget(); theOutputDesc->setByteStream(myFormTarget); // get the DOM representation DOMDocument *doc = parser->getDocument(); // // do the serialization through DOMLSSerializer::write(); // if(gXPathExpression!=NULL) { XMLCh* xpathStr=XMLString::transcode(gXPathExpression); DOMElement* root = doc->getDocumentElement(); try { DOMXPathNSResolver* resolver=doc->createNSResolver(root); DOMXPathResult* result=doc->evaluate( xpathStr, root, resolver, DOMXPathResult::ORDERED_NODE_SNAPSHOT_TYPE, NULL); XMLSize_t nLength = result->getSnapshotLength(); for(XMLSize_t i = 0; i < nLength; i++) { result->snapshotItem(i); theSerializer->write(result->getNodeValue(), theOutputDesc); } result->release(); resolver->release (); } catch(const DOMXPathException& e) { XERCES_STD_QUALIFIER cerr << "An error occurred during processing of the XPath expression. Msg is:" << XERCES_STD_QUALIFIER endl << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; retval = 4; } catch(const DOMException& e) { XERCES_STD_QUALIFIER cerr << "An error occurred during processing of the XPath expression. Msg is:" << XERCES_STD_QUALIFIER endl << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; retval = 4; } XMLString::release(&xpathStr); } else theSerializer->write(doc, theOutputDesc); theOutputDesc->release(); theSerializer->release(); // // Filter, formatTarget and error handler // are NOT owned by the serializer. // delete myFormTarget; delete myErrorHandler; if (gUseFilter) delete myFilter; } catch (const OutOfMemoryException&) { XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl; retval = 5; } catch (XMLException& e) { XERCES_STD_QUALIFIER cerr << "An error occurred during creation of output transcoder. Msg is:" << XERCES_STD_QUALIFIER endl << StrX(e.getMessage()) << XERCES_STD_QUALIFIER endl; retval = 4; } } else retval = 4; // // Clean up the error handler. The parser does not adopt handlers // since they could be many objects or one object installed for multiple // handlers. // delete errReporter; // // Delete the parser itself. Must be done prior to calling Terminate, below. // delete parser; XMLString::release(&gOutputEncoding); // And call the termination method XMLPlatformUtils::Terminate(); return retval; }
list<ClsDataClientConfig> ClsDataClientConfigReader::getDataClientConfig(string strFileName) { #ifdef DEBUG_CLSDATACLIENTCONFIGREADER cout << "ClsDataClientConfigReader::getDataClientConfig()" << endl; #endif list<ClsDataClientConfig> lstConfigs; #ifdef DEBUG_CLSDATACLIENTCONFIGREADER cout << "reading settings from: " << strFileName << endl; #endif bool errorsOccured = false; static bool gDoNamespaces = false; if(!bXMLPlatformInitialized){ try { XMLPlatformUtils::Initialize(); } catch(const XMLException& toCatch) { cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << toCatch.getMessage() << endl; bXMLPlatformInitialized = false; errorsOccured = true; // return; } bXMLPlatformInitialized = true; errorsOccured = false; } //-------------------- if (!errorsOccured) { XercesDOMParser* parser = new XercesDOMParser(); parser->setValidationScheme(XercesDOMParser::Val_Never); /* XercesDOMParser::Val_Never; XercesDOMParser::Val_Auto; XercesDOMParser::Val_Always; */ parser->setDoNamespaces(gDoNamespaces); ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase(); parser->setErrorHandler(errHandler); try { parser->parse(strFileName.c_str()); int errorCount = parser->getErrorCount(); if (errorCount > 0){ errorsOccured = true; } } catch (const XMLException& e) { cerr << "An error occured during parsing (XMLException)\n NMessage: " << XMLString::transcode(e.getMessage()) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage())); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (const DOMException& e) { cerr << "An error occured during parsing (DOMException)\n DMessage: " << XMLString::transcode(e.msg) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.msg)); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (const SAXException& e) { cerr << "An error occured during parsing (SAXException)\n DMessage: " << XMLString::transcode(e.getMessage()) << endl; ClsDataClientConfigReaderException clsDataClientConfigReaderException(XMLString::transcode(e.getMessage())); errorsOccured = true; throw clsDataClientConfigReaderException; } catch (...) { cerr << "An error occured during parsing\n " << endl; errorsOccured = true; ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR); throw clsDataClientConfigReaderException; } /* DOMNode* dnIqrConfig; */ DOMDocument *ddocConfig = parser->getDocument(); DOMNodeList* dnlstClients = ddocConfig->getElementsByTagName(XMLString::transcode(ConfigTagLibrary::DataClientTag())); try{ if(dnlstClients->getLength()>0){ DOMNode* dnValue = NULL; unsigned int ii = 0; while( ii< dnlstClients->getLength()){ DOMNode* dnClient = dnlstClients->item(ii); ii++; string strType = getAttributeValue(dnClient, ConfigTagLibrary::TypeTag(), true); string strID = getAttributeValue(dnClient, ConfigTagLibrary::IDTag(), false); ClsDataClientConfig clsDataClientConfig(strID, strType); DOMNodeList* dnlstClientChildren = dnClient->getChildNodes(); unsigned int i2 = 0; while( i2< dnlstClientChildren->getLength()){ DOMNode* dnClientChild = dnlstClientChildren->item(i2); if(dnClientChild->getNodeType() == 1){ string strName = XMLString::transcode(dnClientChild->getNodeName()); if(!strName.compare(ConfigTagLibrary::PositionTag())){ int iX = 0; int iY = 0; iX = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionXTag(), true)); iY = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::PositionYTag(), true)); clsDataClientConfig.setPosition(iX, iY); } else if(!strName.compare(ConfigTagLibrary::Geometry())){ int iWidth = 0; int iHeight = 0; iWidth = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryWidthTag(), true)); iHeight = iqrUtils::string2int(getAttributeValue(dnClientChild, ConfigTagLibrary::GeometryHeightTag(), true)); clsDataClientConfig.setGeometry(iWidth, iHeight); } else if(!strName.compare(ConfigTagLibrary::StateVariableDisplayTag())){ DOMNodeList* dnlstSVD = dnClientChild->getChildNodes(); unsigned int i3 = 0; while( i3< dnlstSVD->getLength()){ DOMNode* dnSVD = dnlstSVD->item(i3); if(dnSVD->getNodeType() == 1){ string strSVDID = getAttributeValue(dnSVD, ConfigTagLibrary::IDTag(), true); //-- string strItemType = getAttributeValue(dnSVD, ConfigTagLibrary::TypeTag(), true); string strItemID = getAttributeValue(dnSVD, ConfigTagLibrary::ItemIDTag(), true); string strSelectedIndices = getAttributeValue(dnSVD, ConfigTagLibrary::SelectedIndicesTag(), true); ClsStateVariableDisplayConfig clsStateVariableDisplayConfig(/*strItemType,*/ strSVDID, strItemID, strSelectedIndices); DOMNodeList* dnlstSVDParams = dnSVD->getChildNodes(); unsigned int i4 = 0; while( i4< dnlstSVDParams->getLength()){ DOMNode* dnSVDParam = dnlstSVDParams->item(i4); if(dnSVDParam->getNodeType() == 1){ string strParamName = XMLString::transcode(dnSVDParam->getNodeName()); dnValue = dnSVDParam->getFirstChild(); string strParamValue = ""; if(dnValue!=NULL){ strParamValue = XMLString::transcode(dnValue->getNodeValue()); } pair<string, string> pParam(strParamName, strParamValue); clsStateVariableDisplayConfig.addParameter(pParam); } i4++; } clsDataClientConfig.addStateVariableDisplayConfig(clsStateVariableDisplayConfig); } i3++; } } else { string strValue = ""; dnValue = dnClientChild->getFirstChild(); if(dnValue!=NULL){ strValue = XMLString::transcode(dnValue->getNodeValue()); } pair<string, string> pParam(strName, strValue); clsDataClientConfig.addParameter(pParam); } } i2++; } lstConfigs.push_back(clsDataClientConfig); } } } catch (...) { ClsDataClientConfigReaderException clsDataClientConfigReaderException(ClsDataClientConfigReaderException::PARSE_ERROR); throw clsDataClientConfigReaderException; } delete errHandler; } return lstConfigs; };
XERCES_CPP_NAMESPACE_USE int main( int argc, char *argv[] ) { std::cout << "****************************" << std::endl; std::cout << "XML DOM PARSER PLAY" << std::endl; std::cout << "****************************" << std::endl; try { XMLPlatformUtils::Initialize(); } catch( const XMLException& ex ) { std::cerr << "error with xml initialisation:" << ex.getMessage() << std::endl; return 1; } std::cout << "Building parser ..." << std::endl; XercesDOMParser* parser = new XercesDOMParser(); if( !parser ) { std::cerr << "no parser" << std::endl; return 1; } parser->setValidationScheme(XercesDOMParser::Val_Always); parser->setDoNamespaces(false); parser->setDoSchema(false); parser->setCreateEntityReferenceNodes(false); std::cout << "Building error handler" << std::endl; ErrorHandler* errHandler = dynamic_cast<ErrorHandler*>(new HandlerBase()); if( errHandler == 0 ) { std::cerr << "ibad cast" << std::endl; return 1; } if( errHandler == 0 ) { std::cerr << "error with errorhandler caszting:" << std::endl; return 1; } parser->setErrorHandler(errHandler); char* xmlFile = "/home/suggitpe/test/RPMS/config/rpms_config.xml"; try { parser->parse(xmlFile); if( parser->getErrorCount() == 0 ) { std::cerr << "errors in parsing" << std::endl; return 1; } DOMDocument * doc = parser->getDocument(); if( doc->hasChildNodes() ) { std::cout << "Num nodes: " << doc->getChildNodes()->getLength() << std::endl; for( int i = 0; i < doc->getChildNodes()->getLength();++i ) { cout << "\t" << i << " type: " << doc->getChildNodes()->item(i)->getNodeType() << endl; if( doc->getChildNodes()->item(i)->getNodeType() == 1 ) { DOMElement *e = dynamic_cast<DOMElement*>(doc->getChildNodes()->item(i)); if( !e ) { cerr << "bad cast" << endl; } if( e->hasChildNodes() ) { cout << "\t\telement found with " << e->getChildNodes()->getLength() << " nodes"<< endl; } else { cout << "No child nodes" << endl; } } } cout << "now for the other way" << endl; XMLCh * name = XMLString::transcode("system_components"); DOMNodeList *list = doc->getDocumentElement()->getElementsByTagName( name ); XMLString::release(&name); std::cout << "Got list [" << list->getLength() << "]" << std::endl; for( XMLSize_t i =0; i < list->getLength(); ++i ) { std::cout << "." << std::endl; } } else { std::cout << "no child nodes" << std::endl; } } catch( const XMLException& ex ) { std::cerr << "error with xml parser:" << ex.getMessage() << std::endl; return 1; } catch( const DOMException& dex ) { std::cerr << "error with xml parser:" << dex.msg << std::endl; return 1; } catch(...) { std::cerr << "unknown problems" << std::endl; return 1; } delete parser; delete errHandler; std::cout << "****************************" << std::endl; std::cout << "" << std::endl; return 0; }
int parse_header_config(char *filename,int is_credit) { int parse_status = 0 ; // if parse_status is non-zero , return FAILURE struct stat st; if(lstat(filename,&st) != 0) { emit_bypass(FILE_LINE,"configuration file %s doesn't exist,please check ENV HEADER_CONFIG_PATH is set",filename); return FAILURE; } DOMNodeList *nodeList = NULL; DOMNode *node = NULL; try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); emit_bypass(FILE_LINE, "Failed to process file %s", filename); emit_bypass(FILE_LINE, " Error during initialization %s",message); XMLString::release(&message); return FAILURE; } XercesDOMParser* parser = new XercesDOMParser(); parser->setValidationScheme(XercesDOMParser::Val_Always); parser->setDoNamespaces(true); ErrorHandler* errHandler = (ErrorHandler*) new HandlerBase(); parser->setErrorHandler(errHandler); try { parser->parse(filename); DOMDocument *doc = parser->getDocument(); nodeList = doc->getElementsByTagName(XMLString::transcode("xmlns")); node = nodeList->item(0); if (!node) { emit_bypass(FILE_LINE,"xmlns is not found in configurtion file %s",filename); parse_status = 1; } if (parse_status !=1 ) { if(is_credit!=1) { strcpy(gXmlns_str,XMLString::transcode(node->getTextContent())); if (strlen(gXmlns_str) == 0) { emit_bypass(FILE_LINE,"xmlns is set empty in configurtion file %s",filename); parse_status = 1; } } else { strcpy(gXmlns_str_credit,XMLString::transcode(node->getTextContent())); if(strlen(gXmlns_str_credit) == 0) { emit_bypass(FILE_LINE,"xmlns is set empty in configurtion file %s",filename); parse_status = 1; } } } nodeList = doc->getElementsByTagName(XMLString::transcode("xsi")); node = nodeList->item(0); if (!node) { emit_bypass(FILE_LINE,"xsi is not found in configuration file %s",filename); parse_status = 2; } if (parse_status != 2) { if(is_credit!=1) { strcpy(gXsi_str,XMLString::transcode(node->getTextContent())); if (strlen(gXsi_str) == 0) { emit_bypass(FILE_LINE,"xsi is set empty in configurtion file %s",filename); parse_status = 2; } } else { strcpy(gXsi_str_credit,XMLString::transcode(node->getTextContent())); if (strlen(gXsi_str_credit) == 0) { emit_bypass(FILE_LINE,"xsi is set empty in configurtion file %s",filename); parse_status = 2; } } } nodeList = doc->getElementsByTagName(XMLString::transcode("schemaLocation")); node = nodeList->item(0); if (!node) { emit_bypass(FILE_LINE,"schemaLocation is not found in configuration file %s",filename); parse_status = 3; } if (parse_status !=3) { if(is_credit!=1) { strcpy(gSchemaLocation_str,XMLString::transcode(node->getTextContent())); if (strlen(gSchemaLocation_str) == 0) { emit_bypass(FILE_LINE," schemaLocation is set empty in configurtion file %s",filename); parse_status = 3; } } else { strcpy(gSchemaLocation_str_credit,XMLString::transcode(node->getTextContent())); if (strlen(gSchemaLocation_str_credit) == 0) { emit_bypass(FILE_LINE," schemaLocation is set empty in configurtion file %s",filename); parse_status = 3; } } } delete parser; delete errHandler; XMLPlatformUtils::Terminate(); if (parse_status != 0) return FAILURE; return SUCCESS; } catch (const DOMException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); emit_bypass(FILE_LINE, "Failed to process file %s", filename); emit_bypass(FILE_LINE, "Exception message is:%s", message); } catch (exception& e) { emit_bypass(FILE_LINE, "Failed to process file %s", filename); emit_bypass(FILE_LINE, "Exception message is:%s", e.what()); } catch (...){ emit_bypass(FILE_LINE, "Failed to process file %s", filename); } delete parser; delete errHandler; XMLPlatformUtils::Terminate(); return FAILURE; }
void Importer::parseScene (const char* path, Scene *scene) { // Inicialización. try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cout << "Error durante la inicialización! :\n" << message << "\n"; XMLString::release(&message); return; } XercesDOMParser* parser = new XercesDOMParser(); parser->setValidationScheme(XercesDOMParser::Val_Always); // 'Parseando' el fichero xml... try { parser->parse(path); } catch (const XMLException& toCatch) { char* message = XMLString::transcode(toCatch.getMessage()); cout << "Excepción capturada: \n" << message << "\n"; XMLString::release(&message); } catch (const DOMException& toCatch) { char* message = XMLString::transcode(toCatch.msg); cout << "Excepción capturada: \n" << message << "\n"; XMLString::release(&message); } catch (...) { cout << "Excepción no esperada.\n" ; return; } DOMDocument* xmlDoc; DOMElement* elementRoot; try { // Obtener el elemento raíz del documento. xmlDoc = parser->getDocument(); elementRoot = xmlDoc->getDocumentElement(); if(!elementRoot) throw(std::runtime_error("Documento XML vacío.")); } catch (xercesc::XMLException& e ) { char* message = xercesc::XMLString::transcode( e.getMessage() ); ostringstream errBuf; errBuf << "Error 'parseando': " << message << flush; XMLString::release( &message ); return; } XMLCh* camera_ch = XMLString::transcode("camera"); XMLCh* graph_ch = XMLString::transcode("graph"); // Procesando los nodos hijos del raíz... for (XMLSize_t i = 0; i < elementRoot->getChildNodes()->getLength(); ++i ) { DOMNode* node = elementRoot->getChildNodes()->item(i); if (node->getNodeType() == DOMNode::ELEMENT_NODE) { // Nodo <graph>? if (XMLString::equals(node->getNodeName(), graph_ch)) parseGraph(node, scene); } } // Liberar recursos. XMLString::release(&camera_ch); XMLString::release(&graph_ch); delete parser; }
int ParameterManager::LoadDocument(const XERCES_CPP_NAMESPACE_QUALIFIER InputSource& inputSource) { // // Create our parser, then attach an error handler to the parser. // The parser will call back to methods of the ErrorHandler if it // discovers errors during the course of parsing the XML document. // XercesDOMParser *parser = new XercesDOMParser; parser->setValidationScheme(gValScheme); parser->setDoNamespaces(gDoNamespaces); parser->setDoSchema(gDoSchema); parser->setValidationSchemaFullChecking(gSchemaFullChecking); parser->setCreateEntityReferenceNodes(gDoCreate); DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter(); parser->setErrorHandler(errReporter); // // Parse the XML file, catching any XML exceptions that might propagate // out of it. // bool errorsOccured = false; try { parser->parse(inputSource); } catch (const XMLException& e) { std::cerr << "An error occurred during parsing\n Message: " << StrX(e.getMessage()) << std::endl; errorsOccured = true; } catch (const DOMException& e) { std::cerr << "A DOM error occurred during parsing\n DOMException code: " << e.code << std::endl; errorsOccured = true; } catch (...) { std::cerr << "An error occurred during parsing\n " << std::endl; errorsOccured = true; } if (errorsOccured) { delete parser; delete errReporter; return 0; } _pDocument = parser->adoptDocument(); delete parser; delete errReporter; if (!_pDocument) throw XMLBaseException("Malformed Parameter document: Invalid document"); DOMElement* rootElem = _pDocument->getDocumentElement(); if (!rootElem) throw XMLBaseException("Malformed Parameter document: Root group not found"); _pGroupNode = FindElement(rootElem,"FCParamGroup","Root"); if (!_pGroupNode) throw XMLBaseException("Malformed Parameter document: Root group not found"); return 1; }
int parseTEI( const char* xmlFile, bool english, SentenceList& sentenceList ) { try { XMLPlatformUtils::Initialize(); } catch(const XMLException &toCatch) { std::cerr << "Error during Xerces-c Initialization.\n" << " Exception message:" << StrX(toCatch.getMessage()) << std::endl; return 1; } // // Create our parser, then attach an error handler to the parser. // The parser will call back to methods of the ErrorHandler if it // discovers errors during the course of parsing the XML document. // XercesDOMParser *parser = new XercesDOMParser; parser->setValidationScheme(XercesDOMParser::Val_Never); parser->setDoNamespaces(false); parser->setDoSchema(false); parser->setValidationSchemaFullChecking(false); parser->setCreateEntityReferenceNodes(false); DOMTreeErrorReporter *errReporter = new DOMTreeErrorReporter(); parser->setErrorHandler(errReporter); // // Parse the XML file, catching any XML exceptions that might propogate // out of it. // bool errorsOccured = false; try { parser->parse(xmlFile); } catch (const XMLException& e) { std::cerr << "An error occurred during parsing\n Message: " << StrX(e.getMessage()) << std::endl; errorsOccured = true; } catch (const DOMException& e) { const unsigned int maxChars = 2047; XMLCh errText[maxChars + 1]; std::cerr << "\nDOM Error during parsing: '" << xmlFile << "'\n" << "DOMException code is: " << e.code << std::endl; if (DOMImplementation::loadDOMExceptionMsg(e.code, errText, maxChars)) std::cerr << "Message is: " << StrX(errText) << std::endl; errorsOccured = true; } catch (...) { std::cerr << "An error occurred during parsing\n " << std::endl; errorsOccured = true; } if (errorsOccured || errReporter->getSawErrors()) return -1; // get the DOM representation DOMNode *doc = parser->getDocument(); sentenceList.clear(); buildSentenceListFromDOMTree(doc,sentenceList,english); delete errReporter; // Delete the parser itself. Must be done prior to calling Terminate, below. delete parser; // And call the termination method XMLPlatformUtils::Terminate(); return 0; }