void XercesParserLiaison::error(const SAXParseExceptionType& e) { XalanDOMString theMessage = XalanMessageLoader::getMessage(XalanMessages::Error2); formatErrorMessage(e, theMessage); if (m_executionContext != 0) { // We call warn() because we don't want the execution // context to potentially throw an exception. m_executionContext->warn(theMessage); } else { XALAN_USING_STD(cerr) XALAN_USING_STD(endl) cerr << endl << theMessage << endl; } if (m_useValidation == true) { throw e; } }
void MutableNodeRefList::addNodesInDocOrder( const MutableNodeRefList& nodelist, XPathExecutionContext& executionContext) { XALAN_USING_STD(back_inserter); XALAN_USING_STD(copy); XALAN_USING_STD(for_each); const eOrder theOtherOrder = nodelist.m_order; if (theOtherOrder == eUnknownOrder) { for_each( nodelist.m_nodeList.begin(), nodelist.m_nodeList.end(), addNodeInDocOrderFunctor(*this, executionContext)); } else if (theOtherOrder == eDocumentOrder) { if (m_nodeList.empty() == true) { m_nodeList = nodelist.m_nodeList; } else { for_each( nodelist.m_nodeList.begin(), nodelist.m_nodeList.end(), addNodeInDocOrderFunctor(*this, executionContext)); } } else { assert(theOtherOrder == eReverseDocumentOrder); if (m_nodeList.empty() == true) { copy( nodelist.m_nodeList.rbegin(), nodelist.m_nodeList.rend(), back_inserter(m_nodeList)); } else { for_each( nodelist.m_nodeList.rbegin(), nodelist.m_nodeList.rend(), addNodeInDocOrderFunctor(*this, executionContext)); } } }
ElemForEach::~ElemForEach() { XALAN_USING_STD(for_each) for_each(m_sortElems.begin(), m_sortElems.end(), DeleteFunctor<ElemSort>()); }
void XercesParserLiaison::warning(const SAXParseExceptionType& e) { XalanDOMString theMessage = XalanMessageLoader::getMessage(XalanMessages::Warning2); formatErrorMessage(e, theMessage); if (m_executionContext != 0) { m_executionContext->warn(theMessage); } else { XALAN_USING_STD(cerr) XALAN_USING_STD(endl) cerr << endl << theMessage << endl; } }
void XPathFactoryDefault::reset() { XALAN_USING_STD(for_each) for_each(m_xpaths.begin(), m_xpaths.end(), DeleteXPathFunctor(*this, true)); m_xpaths.clear(); }
int main( int /* argc */, char* /* argv */ []) { XALAN_USING_STD(cout) #if !defined(NDEBUG) && defined(_MSC_VER) _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF); _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); #endif XMLPlatformUtils::Initialize(); XalanTransformer::initialize(); { MemoryManagerType& theMemoryManager = XalanMemMgrs::getDefaultXercesMemMgr(); XMLSupportInit theXMLSupportInit; XPathInit theXPathInit( theMemoryManager ); XPathEnvSupportDefault theXPathEnvSupport( theMemoryManager ); XalanSourceTreeDOMSupport theDOMSupport; XObjectFactoryDefault theXObjectFactory( theMemoryManager ); XPathFactoryDefault theXPathFactory( theMemoryManager ); XPathProcessorImpl theXPathProcessor( theMemoryManager ); XPathExecutionContextDefault theExecutionContext(theXPathEnvSupport, theDOMSupport, theXObjectFactory); XalanStdOutputStream theStdOut(cout, theMemoryManager); XalanOutputStreamPrintWriter thePrintWriter(theStdOut); XalanSourceTreeParserLiaison theLiaison(theDOMSupport, theMemoryManager); RunTests(theXPathFactory, theXPathProcessor, theXPathEnvSupport, theDOMSupport, theLiaison, thePrintWriter, theExecutionContext); } XalanTransformer::terminate(); XMLPlatformUtils::Terminate(); return 0; }
void MutableNodeRefList::removeNode(const XalanNode* n) { XALAN_USING_STD(find) NodeListVectorType::iterator i = find(m_nodeList.begin(), m_nodeList.end(), n); if (i != m_nodeList.end()) { m_nodeList.erase(i); } }
void VariablesStack::pushParams(const ParamsVectorType& theParams) { // This object will push the params and pop them // if we don't call it's commit() member function. So // if an exception is thrown while transferring the // parameters, the stack stays in a consistent state. CommitPushParams thePusher(*this); XALAN_USING_STD(for_each) for_each(theParams.begin(), theParams.end(), PushParamFunctor(*this)); thePusher.commit(); }
void MutableNodeRefList::clearNulls() { XALAN_USING_STD(remove); m_nodeList.erase( remove( m_nodeList.begin(), m_nodeList.end(), NodeListVectorType::value_type(0)), m_nodeList.end()); if (m_nodeList.empty() == true) { m_order = eUnknownOrder; } assert(checkForDuplicates(getMemoryManager()) == false); }
XalanDocument* XercesParserLiaison::parseXMLStream( const InputSourceType& reader, const XalanDOMString& /* identifier */) { XalanAutoPtr<DOMParserType> theParser(CreateDOMParser()); if (m_errorHandler == 0) { theParser->setErrorHandler(this); } else { theParser->setErrorHandler(m_errorHandler); } theParser->parse(reader); #if XERCES_VERSION_MAJOR >= 2 DOMDocument_Type* const theXercesDocument = theParser->getDocument(); theXercesDocument->normalize(); #else DOM_Document_Type theXercesDocument = theParser->getDocument(); theXercesDocument.normalize(); #endif #if XERCES_VERSION_MAJOR >= 2 XercesDocumentWrapper* theNewDocument = 0; if (theXercesDocument != 0) { theNewDocument = doCreateDocument(theXercesDocument, m_threadSafe, m_buildWrapper, m_buildMaps, true); theParser->adoptDocument(); #else XercesDocumentBridge* theNewDocument = 0; if (theXercesDocument.isNull() == false) { theNewDocument = doCreateDocument(theXercesDocument, m_threadSafe, m_buildBridge, true); #endif } return theNewDocument; } void XercesParserLiaison::destroyDocument(XalanDocument* theDocument) { const DocumentMapType::iterator i = m_documentMap.find(theDocument); if (i != m_documentMap.end()) { const XalanAutoPtr<XalanDocument> theGuard(theDocument); m_documentMap.erase(i); } } int XercesParserLiaison::getIndent() const { return m_indent; } void XercesParserLiaison::setIndent(int i) { m_indent = i; } bool XercesParserLiaison::getUseValidation() const { return m_useValidation; } void XercesParserLiaison::setUseValidation(bool b) { m_useValidation = b; } const XalanDOMString XercesParserLiaison::getParserDescription() const { return StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("Xerces")); } DOMDocument_Type* XercesParserLiaison::createDOMFactory() { DOMDocument_Type* const theXercesDocument = DOMImplementationType::getImplementation()->createDocument(); createDocument(theXercesDocument, false, false); return theXercesDocument; } void XercesParserLiaison::destroyDocument(DOMDocument_Type* theDocument) { // Delete any live documents... for(DocumentMapType::iterator i = m_documentMap.begin(); i != m_documentMap.end(); ++i) { if ((*i).second.isDeprecated() == false && (*i).second.m_wrapper->getXercesDocument() == theDocument) { destroyDocument((XalanDocument*)(*i).first); } } } bool XercesParserLiaison::getIncludeIgnorableWhitespace() const { return m_includeIgnorableWhitespace; } void XercesParserLiaison::setIncludeIgnorableWhitespace(bool include) { m_includeIgnorableWhitespace = include; } ErrorHandlerType* XercesParserLiaison::getErrorHandler() const { return m_errorHandler; } void XercesParserLiaison::setErrorHandler(ErrorHandlerType* handler) { m_errorHandler = handler; } bool XercesParserLiaison::getDoNamespaces() const { return m_doNamespaces; } void XercesParserLiaison::setDoNamespaces(bool newState) { m_doNamespaces = newState; } bool XercesParserLiaison::getExitOnFirstFatalError() const { return m_exitOnFirstFatalError; } void XercesParserLiaison::setExitOnFirstFatalError(bool newState) { m_exitOnFirstFatalError = newState; } EntityResolverType* XercesParserLiaison::getEntityResolver() const { return m_entityResolver; } void XercesParserLiaison::setEntityResolver(EntityResolverType* resolver) { m_entityResolver = resolver; } const XalanDOMChar* XercesParserLiaison::getExternalSchemaLocation() const { return m_externalSchemaLocation.length() == 0 ? 0 : m_externalSchemaLocation.c_str(); } void XercesParserLiaison::setExternalSchemaLocation(const XalanDOMChar* location) { if (location == 0) { m_externalSchemaLocation.clear(); } else { m_externalSchemaLocation = location; } } const XalanDOMChar* XercesParserLiaison::getExternalNoNamespaceSchemaLocation() const { return m_externalNoNamespaceSchemaLocation.length() == 0 ? 0 : m_externalNoNamespaceSchemaLocation.c_str(); } void XercesParserLiaison::setExternalNoNamespaceSchemaLocation(const XalanDOMChar* location) { if (location == 0) { m_externalNoNamespaceSchemaLocation.clear(); } else { m_externalNoNamespaceSchemaLocation= location; } } #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE) XalanDocument* XercesParserLiaison::createDocument( const DOM_Document_Type& theXercesDocument, bool threadSafe, bool buildBridge) { return doCreateDocument(theXercesDocument, threadSafe, buildBridge); } #endif XalanDocument* XercesParserLiaison::createDocument( const DOMDocument_Type* theXercesDocument, bool threadSafe, bool buildWrapper, bool buildMaps) { // As we did not create the underlying DOMDocument - ensure we don't // delete it later. return doCreateDocument(theXercesDocument, threadSafe, buildWrapper, buildMaps, false); } #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE) XercesDocumentBridge* XercesParserLiaison::mapDocument(const XalanDocument* theDocument) const { const DocumentMapType::const_iterator i = m_documentMap.find(theDocument); return i != m_documentMap.end() ? (*i).second.m_isDeprecated == true ? (*i).second.m_bridge : 0 : 0; } #endif XercesDocumentWrapper* XercesParserLiaison::mapDocumentToWrapper(const XalanDocument* theDocument) const { const DocumentMapType::const_iterator i = m_documentMap.find(theDocument); return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper : 0 : 0; } #if defined(XALAN_BUILD_DEPRECATED_DOM_BRIDGE) DOM_Document_Type XercesParserLiaison::mapXercesDocument(const XalanDocument* theDocument) const { const DocumentMapType::const_iterator i = m_documentMap.find(theDocument); return i != m_documentMap.end() ? (*i).second.isDeprecated() == true ? (*i).second.m_bridge->getXercesDocument() : DOM_Document_Type() : DOM_Document_Type(); } #endif const DOMDocument_Type* XercesParserLiaison::mapToXercesDocument(const XalanDocument* theDocument) const { const DocumentMapType::const_iterator i = m_documentMap.find(theDocument); return i != m_documentMap.end() ? (*i).second.isDeprecated() == false ? (*i).second.m_wrapper->getXercesDocument() : 0 : 0; } void XercesParserLiaison::fatalError(const SAXParseExceptionType& e) { XalanDOMString theMessage = XalanMessageLoader::getMessage(XalanMessages::FatalError); formatErrorMessage(e, theMessage); if (m_executionContext != 0) { // We call warning() because we don't want the execution // context to potentially throw an exception. m_executionContext->warn(theMessage); } else { XALAN_USING_STD(cerr) XALAN_USING_STD(endl) cerr << endl << theMessage << endl; } throw e; }