src/XalanSourceTree/XalanSourceTreeParserLiaison.cpp - xalan-c - Git at Google

 /*
  * The Apache Software License, Version 1.1
  *
  *
  * Copyright (c) 1999-2000 The Apache Software Foundation.  All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
  *    the documentation and/or other materials provided with the
  *    distribution.
  *
  * 3. The end-user documentation included with the redistribution,
  *    if any, must include the following acknowledgment:
  *       "This product includes software developed by the
  *        Apache Software Foundation (http://www.apache.org/)."
  *    Alternately, this acknowledgment may appear in the software itself,
  *    if and wherever such third-party acknowledgments normally appear.
  *
  * 4. The names "Xalan" and "Apache Software Foundation" must
  *    not be used to endorse or promote products derived from this
  *    software without prior written permission. For written
  *    permission, please contact apache@apache.org.
  *
  * 5. Products derived from this software may not be called "Apache",
  *    nor may "Apache" appear in their name, without prior written
  *    permission of the Apache Software Foundation.
  *
  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  * ====================================================================
  *
  * This software consists of voluntary contributions made by many
  * individuals on behalf of the Apache Software Foundation and was
  * originally based on software copyright (c) 1999, International
  * Business Machines, Inc., http://www.ibm.com.  For more
  * information on the Apache Software Foundation, please see
  * <http://www.apache.org/>.
  */
 // Class header file.
 #include "XalanSourceTreeParserLiaison.hpp"


 #include <algorithm>


 #include <sax2/XMLReaderFactory.hpp>


 #include <Include/XalanAutoPtr.hpp>
 #include <Include/STLHelper.hpp>


 #include <PlatformSupport/XalanUnicode.hpp>


 #include "XalanSourceTreeContentHandler.hpp"
 #include "XalanSourceTreeDOMSupport.hpp"
 #include "XalanSourceTreeDocument.hpp"


 // http://xml.org/sax/features/validation
 const XalanDOMChar	XalanSourceTreeParserLiaison::validationString[] = {
 	XalanUnicode::charLetter_h,
 	XalanUnicode::charLetter_t,
 	XalanUnicode::charLetter_t,
 	XalanUnicode::charLetter_p,
 	XalanUnicode::charColon,
 	XalanUnicode::charSolidus,
 	XalanUnicode::charSolidus,
 	XalanUnicode::charLetter_x,
 	XalanUnicode::charLetter_m,
 	XalanUnicode::charLetter_l,
 	XalanUnicode::charFullStop,
 	XalanUnicode::charLetter_o,
 	XalanUnicode::charLetter_r,
 	XalanUnicode::charLetter_g,
 	XalanUnicode::charSolidus,
 	XalanUnicode::charLetter_s,
 	XalanUnicode::charLetter_a,
 	XalanUnicode::charLetter_x,
 	XalanUnicode::charSolidus,
 	XalanUnicode::charLetter_f,
 	XalanUnicode::charLetter_e,
 	XalanUnicode::charLetter_a,
 	XalanUnicode::charLetter_t,
 	XalanUnicode::charLetter_u,
 	XalanUnicode::charLetter_r,
 	XalanUnicode::charLetter_e,
 	XalanUnicode::charLetter_s,
 	XalanUnicode::charSolidus,
 	XalanUnicode::charLetter_v,
 	XalanUnicode::charLetter_a,
 	XalanUnicode::charLetter_l,
 	XalanUnicode::charLetter_i,
 	XalanUnicode::charLetter_d,
 	XalanUnicode::charLetter_a,
 	XalanUnicode::charLetter_t,
 	XalanUnicode::charLetter_i,
 	XalanUnicode::charLetter_o,
 	XalanUnicode::charLetter_n,
 	0
 };


 XalanSourceTreeParserLiaison::XalanSourceTreeParserLiaison(XalanSourceTreeDOMSupport&	/* theSupport */) :
 	m_documentNumber(0),
 	m_xercesParserLiaison(),
 	m_documentMap(),
 	m_persistentDocumentMap(),
 	m_poolAllText(true)
 {
 }


 XalanSourceTreeParserLiaison::XalanSourceTreeParserLiaison() :
 	m_xercesParserLiaison(),
 	m_documentMap(),
 	m_persistentDocumentMap(),
 	m_poolAllText(true)
 {
 }


 XalanSourceTreeParserLiaison::~XalanSourceTreeParserLiaison()
 {
 	reset();

 #if !defined(XALAN_NO_NAMESPACES)
 	using std::for_each;
 #endif

 	// Delete any persistent documents.
 	for_each(m_persistentDocumentMap.begin(),
 			 m_persistentDocumentMap.end(),
 			 makeMapValueDeleteFunctor(m_persistentDocumentMap));

 	m_persistentDocumentMap.clear();
 }


 void
 XalanSourceTreeParserLiaison::reset()
 {
 #if !defined(XALAN_NO_NAMESPACES)
 	using std::for_each;
 #endif

 	// Delete any documents.
 	for_each(m_documentMap.begin(),
 			 m_documentMap.end(),
 			 makeMapValueDeleteFunctor(m_documentMap));

 	m_documentMap.clear();

 	m_xercesParserLiaison.reset();
 }


 ExecutionContext*
 XalanSourceTreeParserLiaison::getExecutionContext() const
 {
 	return m_xercesParserLiaison.getExecutionContext();
 }


 void
 XalanSourceTreeParserLiaison::setExecutionContext(ExecutionContext&		theContext)
 {
 	m_xercesParserLiaison.setExecutionContext(theContext);
 }


 void
 XalanSourceTreeParserLiaison::parseXMLStream(
 			const InputSource&		inputSource,
 			DocumentHandler&		handler,
 			const XalanDOMString&	identifier)
 {
 	m_xercesParserLiaison.parseXMLStream(inputSource, handler, identifier);
 }


 XalanDocument*
 XalanSourceTreeParserLiaison::parseXMLStream(
 			const InputSource&		inputSource,
 			const XalanDOMString&	/* identifier */)
 {
 	XalanSourceTreeContentHandler	theContentHandler(createXalanSourceTreeDocument());

 	XalanAutoPtr<SAX2XMLReader>		theReader(XMLReaderFactory::createXMLReader());

 	theReader->setFeature(
 		validationString,
 		m_xercesParserLiaison.getUseValidation());

 	theReader->setContentHandler(&theContentHandler);

 	theReader->setDTDHandler(&theContentHandler);

 	theReader->setErrorHandler(&m_xercesParserLiaison);

 	theReader->setLexicalHandler(&theContentHandler);

 	theReader->setEntityResolver(getEntityResolver());

 	theReader->parse(inputSource);

 	return theContentHandler.getDocument();
 }


 XalanDocument*
 XalanSourceTreeParserLiaison::createDocument()
 {
 	return createXalanSourceTreeDocument();
 }


 XalanDocument*
 XalanSourceTreeParserLiaison::createDOMFactory()
 {
 	return m_xercesParserLiaison.createDocument();
 }


 void
 XalanSourceTreeParserLiaison::destroyDocument(XalanDocument*		theDocument)
 {
 	if (mapDocument(theDocument) != 0)
 	{
 		m_documentMap.erase(theDocument);

 		delete theDocument;
 	}
 }


 unsigned long
 XalanSourceTreeParserLiaison::getDocumentNumber()
 {
 	return m_documentNumber++;
 }


 int
 XalanSourceTreeParserLiaison::getIndent() const
 {
 	return m_xercesParserLiaison.getIndent();
 }


 void
 XalanSourceTreeParserLiaison::setIndent(int		i)
 {
 	m_xercesParserLiaison.setIndent(i);
 }


 bool
 XalanSourceTreeParserLiaison::getUseValidation() const
 {
 	return m_xercesParserLiaison.getUseValidation();
 }


 void
 XalanSourceTreeParserLiaison::setUseValidation(bool		b)
 {
 	m_xercesParserLiaison.setUseValidation(b);
 }


 const XalanDOMString
 XalanSourceTreeParserLiaison::getParserDescription() const
 {
 	return XALAN_STATIC_UCODE_STRING("XalanSourceTree");
 }


 void
 XalanSourceTreeParserLiaison::parseXMLStream(
 			const InputSource&		theInputSource,
 			ContentHandler&			theContentHandler,
 			DTDHandler*				theDTDHandler,
 			LexicalHandler*			theLexicalHandler,
 			const XalanDOMString&	/* theIdentifier */)
 {
 	XalanAutoPtr<SAX2XMLReader>		theReader(XMLReaderFactory::createXMLReader());

 	theReader->setFeature(
 		validationString,
 		m_xercesParserLiaison.getUseValidation());

 	theReader->setContentHandler(&theContentHandler);

 	theReader->setDTDHandler(theDTDHandler);

 	theReader->setErrorHandler(&m_xercesParserLiaison);

 	theReader->setLexicalHandler(theLexicalHandler);

 	EntityResolver* const	theResolver = getEntityResolver();

 	if (theResolver != 0)
 	{
 		theReader->setEntityResolver(theResolver);
 	}

 	theReader->parse(theInputSource);
 }


 bool
 XalanSourceTreeParserLiaison::getIncludeIgnorableWhitespace() const
 {
 	return m_xercesParserLiaison.getIncludeIgnorableWhitespace();
 }


 void
 XalanSourceTreeParserLiaison::setIncludeIgnorableWhitespace(bool	include)
 {
 	m_xercesParserLiaison.setIncludeIgnorableWhitespace(include);
 }


 ErrorHandler*
 XalanSourceTreeParserLiaison::getErrorHandler()
 {
 	return m_xercesParserLiaison.getErrorHandler();
 }


 const ErrorHandler*
 XalanSourceTreeParserLiaison::getErrorHandler() const
 {
 	return m_xercesParserLiaison.getErrorHandler();
 }


 void
 XalanSourceTreeParserLiaison::setErrorHandler(ErrorHandler*	handler)
 {
 	m_xercesParserLiaison.setErrorHandler(handler);
 }


 bool
 XalanSourceTreeParserLiaison::getDoNamespaces() const
 {
 	return m_xercesParserLiaison.getDoNamespaces();
 }


 void
 XalanSourceTreeParserLiaison::setDoNamespaces(bool	newState)
 {
 	m_xercesParserLiaison.setDoNamespaces(newState);
 }


 bool
 XalanSourceTreeParserLiaison::getExitOnFirstFatalError() const
 {
 	return m_xercesParserLiaison.getExitOnFirstFatalError();
 }


 void
 XalanSourceTreeParserLiaison::setExitOnFirstFatalError(bool		newState)
 {
 	m_xercesParserLiaison.setExitOnFirstFatalError(newState);
 }


 EntityResolver*
 XalanSourceTreeParserLiaison::getEntityResolver()
 {
 	return m_xercesParserLiaison.getEntityResolver();
 }


 void
 XalanSourceTreeParserLiaison::setEntityResolver(EntityResolver*	resolver)
 {
 	m_xercesParserLiaison.setEntityResolver(resolver);
 }


 XalanSourceTreeDocument*
 XalanSourceTreeParserLiaison::mapDocument(const XalanDocument*	theDocument) const
 {
 	DocumentMapType::const_iterator		i =
 		m_documentMap.find(theDocument);

 	if (i != m_documentMap.end())
 	{
 		return (*i).second;
 	}
 	else
 	{
 		i =	m_persistentDocumentMap.find(theDocument);

 		if (i != m_persistentDocumentMap.end())
 		{
 			return (*i).second;
 		}
 		else
 		{
 			return 0;
 		}
 	}
 }


 XalanSourceTreeDocument*
 XalanSourceTreeParserLiaison::createXalanSourceTreeDocument()
 {
 	XalanSourceTreeDocument* const	theNewDocument =
 		new XalanSourceTreeDocument(m_documentNumber++, m_poolAllText);

 	m_documentMap[theNewDocument] = theNewDocument;

 	return theNewDocument;
 }


 bool
 XalanSourceTreeParserLiaison::setPersistent(XalanSourceTreeDocument*	theDocument)
 {
 	const DocumentMapType::iterator		i =
 		m_documentMap.find(theDocument);

 	if (i != m_documentMap.end())
 	{
 		return false;
 	}
 	else
 	{
 		m_persistentDocumentMap[(*i).first] = (*i).second;

 		m_documentMap.erase(i);

 		return true;
 	}
 }


 bool
 XalanSourceTreeParserLiaison::unsetPersistent(XalanSourceTreeDocument*	theDocument)
 {
 	const DocumentMapType::iterator		i =
 		m_persistentDocumentMap.find(theDocument);

 	if (i != m_persistentDocumentMap.end())
 	{
 		return false;
 	}
 	else
 	{
 		m_documentMap[(*i).first] = (*i).second;

 		m_persistentDocumentMap.erase(i);

 		return true;
 	}
 }
	/*
	* The Apache Software License, Version 1.1
	*
	*
	* Copyright (c) 1999-2000 The Apache Software Foundation. All rights
	* reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	*
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	*
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in
	* the documentation and/or other materials provided with the
	* distribution.
	*
	* 3. The end-user documentation included with the redistribution,
	* if any, must include the following acknowledgment:
	* "This product includes software developed by the
	* Apache Software Foundation (http://www.apache.org/)."
	* Alternately, this acknowledgment may appear in the software itself,
	* if and wherever such third-party acknowledgments normally appear.
	*
	* 4. The names "Xalan" and "Apache Software Foundation" must
	* not be used to endorse or promote products derived from this
	* software without prior written permission. For written
	* permission, please contact apache@apache.org.
	*
	* 5. Products derived from this software may not be called "Apache",
	* nor may "Apache" appear in their name, without prior written
	* permission of the Apache Software Foundation.
	*
	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
	* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
	* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	* ====================================================================
	*
	* This software consists of voluntary contributions made by many
	* individuals on behalf of the Apache Software Foundation and was
	* originally based on software copyright (c) 1999, International
	* Business Machines, Inc., http://www.ibm.com. For more
	* information on the Apache Software Foundation, please see
	* <http://www.apache.org/>.
	*/
	// Class header file.
	#include "XalanSourceTreeParserLiaison.hpp"



	#include <algorithm>



	#include <sax2/XMLReaderFactory.hpp>



	#include <Include/XalanAutoPtr.hpp>
	#include <Include/STLHelper.hpp>



	#include <PlatformSupport/XalanUnicode.hpp>



	#include "XalanSourceTreeContentHandler.hpp"
	#include "XalanSourceTreeDOMSupport.hpp"
	#include "XalanSourceTreeDocument.hpp"



	// http://xml.org/sax/features/validation
	const XalanDOMChar XalanSourceTreeParserLiaison::validationString[] = {
	XalanUnicode::charLetter_h,
	XalanUnicode::charLetter_t,
	XalanUnicode::charLetter_t,
	XalanUnicode::charLetter_p,
	XalanUnicode::charColon,
	XalanUnicode::charSolidus,
	XalanUnicode::charSolidus,
	XalanUnicode::charLetter_x,
	XalanUnicode::charLetter_m,
	XalanUnicode::charLetter_l,
	XalanUnicode::charFullStop,
	XalanUnicode::charLetter_o,
	XalanUnicode::charLetter_r,
	XalanUnicode::charLetter_g,
	XalanUnicode::charSolidus,
	XalanUnicode::charLetter_s,
	XalanUnicode::charLetter_a,
	XalanUnicode::charLetter_x,
	XalanUnicode::charSolidus,
	XalanUnicode::charLetter_f,
	XalanUnicode::charLetter_e,
	XalanUnicode::charLetter_a,
	XalanUnicode::charLetter_t,
	XalanUnicode::charLetter_u,
	XalanUnicode::charLetter_r,
	XalanUnicode::charLetter_e,
	XalanUnicode::charLetter_s,
	XalanUnicode::charSolidus,
	XalanUnicode::charLetter_v,
	XalanUnicode::charLetter_a,
	XalanUnicode::charLetter_l,
	XalanUnicode::charLetter_i,
	XalanUnicode::charLetter_d,
	XalanUnicode::charLetter_a,
	XalanUnicode::charLetter_t,
	XalanUnicode::charLetter_i,
	XalanUnicode::charLetter_o,
	XalanUnicode::charLetter_n,
	0
	};



	XalanSourceTreeParserLiaison::XalanSourceTreeParserLiaison(XalanSourceTreeDOMSupport& /* theSupport */) :
	m_documentNumber(0),
	m_xercesParserLiaison(),
	m_documentMap(),
	m_persistentDocumentMap(),
	m_poolAllText(true)
	{
	}



	XalanSourceTreeParserLiaison::XalanSourceTreeParserLiaison() :
	m_xercesParserLiaison(),
	m_documentMap(),
	m_persistentDocumentMap(),
	m_poolAllText(true)
	{
	}



	XalanSourceTreeParserLiaison::~XalanSourceTreeParserLiaison()
	{
	reset();

	#if !defined(XALAN_NO_NAMESPACES)
	using std::for_each;
	#endif

	// Delete any persistent documents.
	for_each(m_persistentDocumentMap.begin(),
	m_persistentDocumentMap.end(),
	makeMapValueDeleteFunctor(m_persistentDocumentMap));

	m_persistentDocumentMap.clear();
	}



	void
	XalanSourceTreeParserLiaison::reset()
	{
	#if !defined(XALAN_NO_NAMESPACES)
	using std::for_each;
	#endif

	// Delete any documents.
	for_each(m_documentMap.begin(),
	m_documentMap.end(),
	makeMapValueDeleteFunctor(m_documentMap));

	m_documentMap.clear();

	m_xercesParserLiaison.reset();
	}



	ExecutionContext*
	XalanSourceTreeParserLiaison::getExecutionContext() const
	{
	return m_xercesParserLiaison.getExecutionContext();
	}



	void
	XalanSourceTreeParserLiaison::setExecutionContext(ExecutionContext& theContext)
	{
	m_xercesParserLiaison.setExecutionContext(theContext);
	}



	void
	XalanSourceTreeParserLiaison::parseXMLStream(
	const InputSource& inputSource,
	DocumentHandler& handler,
	const XalanDOMString& identifier)
	{
	m_xercesParserLiaison.parseXMLStream(inputSource, handler, identifier);
	}



	XalanDocument*
	XalanSourceTreeParserLiaison::parseXMLStream(
	const InputSource& inputSource,
	const XalanDOMString& /* identifier */)
	{
	XalanSourceTreeContentHandler theContentHandler(createXalanSourceTreeDocument());

	XalanAutoPtr<SAX2XMLReader> theReader(XMLReaderFactory::createXMLReader());

	theReader->setFeature(
	validationString,
	m_xercesParserLiaison.getUseValidation());

	theReader->setContentHandler(&theContentHandler);

	theReader->setDTDHandler(&theContentHandler);

	theReader->setErrorHandler(&m_xercesParserLiaison);

	theReader->setLexicalHandler(&theContentHandler);

	theReader->setEntityResolver(getEntityResolver());

	theReader->parse(inputSource);

	return theContentHandler.getDocument();
	}



	XalanDocument*
	XalanSourceTreeParserLiaison::createDocument()
	{
	return createXalanSourceTreeDocument();
	}



	XalanDocument*
	XalanSourceTreeParserLiaison::createDOMFactory()
	{
	return m_xercesParserLiaison.createDocument();
	}



	void
	XalanSourceTreeParserLiaison::destroyDocument(XalanDocument* theDocument)
	{
	if (mapDocument(theDocument) != 0)
	{
	m_documentMap.erase(theDocument);

	delete theDocument;
	}
	}



	unsigned long
	XalanSourceTreeParserLiaison::getDocumentNumber()
	{
	return m_documentNumber++;
	}



	int
	XalanSourceTreeParserLiaison::getIndent() const
	{
	return m_xercesParserLiaison.getIndent();
	}



	void
	XalanSourceTreeParserLiaison::setIndent(int i)
	{
	m_xercesParserLiaison.setIndent(i);
	}



	bool
	XalanSourceTreeParserLiaison::getUseValidation() const
	{
	return m_xercesParserLiaison.getUseValidation();
	}



	void
	XalanSourceTreeParserLiaison::setUseValidation(bool b)
	{
	m_xercesParserLiaison.setUseValidation(b);
	}



	const XalanDOMString
	XalanSourceTreeParserLiaison::getParserDescription() const
	{
	return XALAN_STATIC_UCODE_STRING("XalanSourceTree");
	}



	void
	XalanSourceTreeParserLiaison::parseXMLStream(
	const InputSource& theInputSource,
	ContentHandler& theContentHandler,
	DTDHandler* theDTDHandler,
	LexicalHandler* theLexicalHandler,
	const XalanDOMString& /* theIdentifier */)
	{
	XalanAutoPtr<SAX2XMLReader> theReader(XMLReaderFactory::createXMLReader());

	theReader->setFeature(
	validationString,
	m_xercesParserLiaison.getUseValidation());

	theReader->setContentHandler(&theContentHandler);

	theReader->setDTDHandler(theDTDHandler);

	theReader->setErrorHandler(&m_xercesParserLiaison);

	theReader->setLexicalHandler(theLexicalHandler);

	EntityResolver* const theResolver = getEntityResolver();

	if (theResolver != 0)
	{
	theReader->setEntityResolver(theResolver);
	}

	theReader->parse(theInputSource);
	}



	bool
	XalanSourceTreeParserLiaison::getIncludeIgnorableWhitespace() const
	{
	return m_xercesParserLiaison.getIncludeIgnorableWhitespace();
	}



	void
	XalanSourceTreeParserLiaison::setIncludeIgnorableWhitespace(bool include)
	{
	m_xercesParserLiaison.setIncludeIgnorableWhitespace(include);
	}



	ErrorHandler*
	XalanSourceTreeParserLiaison::getErrorHandler()
	{
	return m_xercesParserLiaison.getErrorHandler();
	}



	const ErrorHandler*
	XalanSourceTreeParserLiaison::getErrorHandler() const
	{
	return m_xercesParserLiaison.getErrorHandler();
	}



	void
	XalanSourceTreeParserLiaison::setErrorHandler(ErrorHandler* handler)
	{
	m_xercesParserLiaison.setErrorHandler(handler);
	}



	bool
	XalanSourceTreeParserLiaison::getDoNamespaces() const
	{
	return m_xercesParserLiaison.getDoNamespaces();
	}



	void
	XalanSourceTreeParserLiaison::setDoNamespaces(bool newState)
	{
	m_xercesParserLiaison.setDoNamespaces(newState);
	}



	bool
	XalanSourceTreeParserLiaison::getExitOnFirstFatalError() const
	{
	return m_xercesParserLiaison.getExitOnFirstFatalError();
	}



	void
	XalanSourceTreeParserLiaison::setExitOnFirstFatalError(bool newState)
	{
	m_xercesParserLiaison.setExitOnFirstFatalError(newState);
	}



	EntityResolver*
	XalanSourceTreeParserLiaison::getEntityResolver()
	{
	return m_xercesParserLiaison.getEntityResolver();
	}



	void
	XalanSourceTreeParserLiaison::setEntityResolver(EntityResolver* resolver)
	{
	m_xercesParserLiaison.setEntityResolver(resolver);
	}



	XalanSourceTreeDocument*
	XalanSourceTreeParserLiaison::mapDocument(const XalanDocument* theDocument) const
	{
	DocumentMapType::const_iterator i =
	m_documentMap.find(theDocument);

	if (i != m_documentMap.end())
	{
	return (*i).second;
	}
	else
	{
	i = m_persistentDocumentMap.find(theDocument);

	if (i != m_persistentDocumentMap.end())
	{
	return (*i).second;
	}
	else
	{
	return 0;
	}
	}
	}



	XalanSourceTreeDocument*
	XalanSourceTreeParserLiaison::createXalanSourceTreeDocument()
	{
	XalanSourceTreeDocument* const theNewDocument =
	new XalanSourceTreeDocument(m_documentNumber++, m_poolAllText);

	m_documentMap[theNewDocument] = theNewDocument;

	return theNewDocument;
	}



	bool
	XalanSourceTreeParserLiaison::setPersistent(XalanSourceTreeDocument* theDocument)
	{
	const DocumentMapType::iterator i =
	m_documentMap.find(theDocument);

	if (i != m_documentMap.end())
	{
	return false;
	}
	else
	{
	m_persistentDocumentMap[(i).first] = (i).second;

	m_documentMap.erase(i);

	return true;
	}
	}


	bool
	XalanSourceTreeParserLiaison::unsetPersistent(XalanSourceTreeDocument* theDocument)
	{
	const DocumentMapType::iterator i =
	m_persistentDocumentMap.find(theDocument);

	if (i != m_persistentDocumentMap.end())
	{
	return false;
	}
	else
	{
	m_documentMap[(i).first] = (i).second;

	m_persistentDocumentMap.erase(i);

	return true;
	}
	}