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