diff --git a/Tests/Harness/HarnessInit.cpp b/Tests/Harness/HarnessInit.cpp
deleted file mode 100644
index 6f3d233..0000000
--- a/Tests/Harness/HarnessInit.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 1999-2001 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/>.
- *
- *
- */
-
-#include "HarnessInit.hpp"
-
-
-
-#include <util/PlatformUtils.hpp>
-
-
-
-#include <XalanDOM/XalanDOMInit.hpp>
-
-
-
-#include "FileUtility.hpp"
-
-
-
-static const XalanDOMInit*	s_xalanDOMInit = 0;
-
-HarnessInit::HarnessInit()
-{
-	assert(s_xalanDOMInit == 0);
-
-	XMLPlatformUtils::Initialize();
-
-	s_xalanDOMInit = new XalanDOMInit;
-
-	FileUtility::initialize();
-}
-
-
-
-HarnessInit::~HarnessInit()
-{
-	FileUtility::terminate();
-
-	delete s_xalanDOMInit;
-
-	s_xalanDOMInit = 0;
-
-	XMLPlatformUtils::Terminate();
-}
diff --git a/samples/ParsedSourceWrappers/ParsedSourceWrappers.cpp b/samples/ParsedSourceWrappers/ParsedSourceWrappers.cpp
deleted file mode 100644
index 29884a2..0000000
--- a/samples/ParsedSourceWrappers/ParsedSourceWrappers.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 2002 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/>.
- */
-
-#include <Include/PlatformDefinitions.hpp>
-
-
-
-#include <cassert>
-#if defined(XALAN_OLD_STREAM_HEADERS)
-#include <iostream.h>
-#else
-#include <iostream>
-#endif
-
-
-
-#include <framework/URLInputSource.hpp>
-#include <parsers/DOMParser.hpp>
-#include <util/PlatformUtils.hpp>
-
-
-
-#include <PlatformSupport/URISupport.hpp>
-
-
-
-#include <XercesParserLiaison/XercesParserLiaison.hpp>
-#include <XercesParserLiaison/XercesDOMSupport.hpp>
-
-
-
-#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
-#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
-
-
-
-#include <XalanTransformer/XalanTransformer.hpp>
-#include <XalanTransformer/XercesDOMWrapperParsedSource.hpp>
-#include <XalanTransformer/XalanSourceTreeWrapperParsedSource.hpp>
-
-
-
-int
-transformXercesDOM(
-			XalanTransformer&				theTransformer,
-			const XalanDOMString&			theURI,
-			const XalanCompiledStylesheet*	theStylesheet,
-			const XSLTResultTarget&			theResultTarget)
-{
-	const URLInputSource	theInputSource(theURI.c_str());
-
-	DOMParser				theParser;
-
-	theParser.parse(theInputSource);
-
-	DOM_Document			theDocument = theParser.getDocument();
-
-	XercesParserLiaison		theParserLiaison;
-	XercesDOMSupport		theDOMSupport;
-
-	XercesDOMWrapperParsedSource	theWrapper(theDocument, theParserLiaison, theDOMSupport, theURI);
-
-	return theTransformer.transform(
-						theWrapper,
-						theStylesheet,
-						theResultTarget);
-}
-
-
-
-int
-transformXalanSourceTree(
-			XalanTransformer&				theTransformer,
-			const XalanDOMString&			theURI,
-			const XalanCompiledStylesheet*	theStylesheet,
-			const XSLTResultTarget&			theResultTarget)
-{
-	const URLInputSource			theInputSource(theURI.c_str());
-
-	XalanSourceTreeParserLiaison	theParserLiaison;
-	XalanSourceTreeDOMSupport		theDOMSupport(theParserLiaison);
-
-	XalanDocument* const	theDocument = theParserLiaison.parseXMLStream(theInputSource, theURI);
-
-	XalanSourceTreeDocument* const	theSourceTreeDocument = theParserLiaison.mapDocument(theDocument);
-	assert(theSourceTreeDocument != 0);
-
-	XalanSourceTreeWrapperParsedSource	theWrapper(theSourceTreeDocument, theParserLiaison, theDOMSupport, theURI);
-
-	return theTransformer.transform(
-						theWrapper,
-						theStylesheet,
-						theResultTarget);
-}
-
-
-
-int
-transform()
-{
-#if !defined(XALAN_NO_NAMESPACES)
-	using std::cout;
-	using std::cerr;
-    using std::endl;
-#endif
-
-	int		theResult = -1;
-
-	try
-	{
-		// Create a XalanTransformer.
-		XalanTransformer	theTransformer;
-
-		const XSLTInputSource	theStylesheetInputSource("foo.xsl");
-
-		// Let's compile the stylesheet and re-use it...
-		const XalanCompiledStylesheet*		theStylesheet = 0;
-
-		if (theTransformer.compileStylesheet(theStylesheetInputSource, theStylesheet) != 0)
-		{
-			cerr << "An error occurred compiling the stylesheet: "
-				 << theTransformer.getLastError()
-				 << endl;
-		}
-		else
-		{
-			assert(theStylesheet != 0);
-
-			const XalanDOMString	theInputFile("foo.xml");
-
-			const XalanDOMString	theURI(URISupport::getURLStringFromString(theInputFile));
-
-			const XSLTResultTarget	theResultTarget(cout);
-
-			theResult = transformXercesDOM(theTransformer, theURI, theStylesheet, theResultTarget);
-
-			if (theResult == 0)
-			{
-				cout << endl;
-
-				theResult = transformXalanSourceTree(theTransformer, theURI, theStylesheet, theResultTarget);
-			}
-
-			if (theResult != 0)
-			{
-				cerr << "Transformation failed: " << theTransformer.getLastError() << endl;
-			}
-		}
-	}
-	catch(...)
-	{
-		cerr << "An unknown error occurred!" << endl;
-	}
-
-	return theResult;
-}
-
-// This sample shows how existing Xerces DOM_Document instances and XalanSourceTreeDocument
-// instances can be wrapped to use as input for to an instance of XalanTransformer.
-int
-main(
-			int				 argc,
-			const char*		 /* argv */[])
-{
-#if !defined(XALAN_NO_NAMESPACES)
-	using std::cout;
-	using std::cerr;
-    using std::endl;
-#endif
-
-	int		theResult = -1;
-
-    if (argc != 1)
-	{
-		cerr << "Usage: ParsedSourceWrappers" << endl;
-	}
-	else
-	{
-		try
-		{
-			// Call the static initializer for Xerces.
-			XMLPlatformUtils::Initialize();
-
-			// Initialize Xalan.
-			XalanTransformer::initialize();
-
-			theResult = transform();
-
-			// Terminate Xalan.
-			XalanTransformer::terminate();
-
-			// Call the static terminator for Xerces.
-			XMLPlatformUtils::Terminate();
-		}
-		catch(...)
-		{
-			cerr << "Initialization failed!" << endl;
-		}
-	}
-
-	return theResult;
-}
diff --git a/src/XercesParserLiaison/XercesDocumentNamedNodeListCache.hpp b/src/XercesParserLiaison/XercesDocumentNamedNodeListCache.hpp
deleted file mode 100644
index 6eddf0c..0000000
--- a/src/XercesParserLiaison/XercesDocumentNamedNodeListCache.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 1999 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/>.
- */
-#if !defined(XERCESDOCUMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680)
-#define XERCESDOCUMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680
-
-
-
-#include <XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
-
-
-
-#include <dom/DOM_Document.hpp>
-
-
-
-#include <XercesParserLiaison/XercesNamedNodeListCache.hpp>
-
-
-
-class XALAN_XERCESPARSERLIAISON_EXPORT XercesDocumentNamedNodeListCache : public XercesNamedNodeListCache
-{
-public:
-
-	XercesDocumentNamedNodeListCache(
-			const DOM_Document&				theXercesDocument,
-			const XercesBridgeNavigator&	theNavigator);
-
-	virtual
-	~XercesDocumentNamedNodeListCache();
-
-protected:
-
-	virtual DOM_NodeList
-	getXercesNodeList(const XalanDOMString&		tagname) const;
-
-	virtual DOM_NodeList
-	getXercesNodeList(
-			const XalanDOMString&	namespaceURI,
-			const XalanDOMString&	localName) const;
-
-private:
-
-	const DOM_Document	m_xercesDocument;
-};
-
-
-
-#endif	// !defined(XERCESDOCUMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680)
diff --git a/src/XercesParserLiaison/XercesElementNamedNodeListCache.hpp b/src/XercesParserLiaison/XercesElementNamedNodeListCache.hpp
deleted file mode 100644
index 965d5e0..0000000
--- a/src/XercesParserLiaison/XercesElementNamedNodeListCache.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 1999 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/>.
- */
-#if !defined(XERCESELEMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680)
-#define XERCESELEMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680
-
-
-
-#include <XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
-
-
-
-#include <dom/DOM_Element.hpp>
-
-
-
-#include <XercesParserLiaison/XercesNamedNodeListCache.hpp>
-
-
-
-class XALAN_XERCESPARSERLIAISON_EXPORT XercesElementNamedNodeListCache : public XercesNamedNodeListCache
-{
-public:
-
-	XercesElementNamedNodeListCache(
-			const DOM_Element&				theXercesElement,
-			const XercesBridgeNavigator&	theNavigator);
-
-	virtual
-	~XercesElementNamedNodeListCache();
-
-protected:
-
-	virtual DOM_NodeList
-	getXercesNodeList(const XalanDOMString&		tagname) const;
-
-	virtual DOM_NodeList
-	getXercesNodeList(
-			const XalanDOMString&	namespaceURI,
-			const XalanDOMString&	localName) const;
-
-private:
-
-	const DOM_Element	m_xercesElement;
-};
-
-
-
-#endif	// !defined(XERCESELEMENTNAMEDNODELISTCACHE_HEADER_GUARD_1357924680)
diff --git a/src/XercesParserLiaison/XercesNamedNodeMapBridge.hpp b/src/XercesParserLiaison/XercesNamedNodeMapBridge.hpp
deleted file mode 100644
index 69d4cfb..0000000
--- a/src/XercesParserLiaison/XercesNamedNodeMapBridge.hpp
+++ /dev/null
@@ -1,272 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 1999 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/>.
- */
-#if !defined(XERCESNAMEDNODEMAPBRIDGE_HEADER_GUARD_1357924680)
-#define XERCESNAMEDNODEMAPBRIDGE_HEADER_GUARD_1357924680
-
-
-
-#include <XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
-
-
-
-#include <dom/DOM_NamedNodeMap.hpp>
-
-
-
-#include <XalanDOM/XalanNamedNodeMap.hpp>
-
-
-
-class XercesBridgeNavigator;
-class XercesNodeBridge;
-
-
-
-class XALAN_XERCESPARSERLIAISON_EXPORT XercesNamedNodeMapBridge : public XalanNamedNodeMap
-{
-public:
-
-	XercesNamedNodeMapBridge(
-			const DOM_NamedNodeMap&			theXercesNamedNodeMap,
-			const XercesBridgeNavigator&	theNavigator);
-
-	virtual
-	~XercesNamedNodeMapBridge();
-
-	/** @name Set functions. */
-	//@{
-
-	/**
-	 * Adds a node using its <code>nodeName</code> attribute. 
-	 *
-	 * <br>As the <code>nodeName</code> attribute is used to derive the name 
-	 * which the node must be stored under, multiple nodes of certain types 
-	 * (those that have a "special" string value) cannot be stored as the names 
-	 * would clash. This is seen as preferable to allowing nodes to be aliased.
-	 * @param arg A node to store in a named node map. The node will later be 
-	 *	 accessible using the value of the <code>nodeName</code> attribute of 
-	 *	 the node. If a node with that name is already present in the map, it 
-	 *	 is replaced by the new one.
-	 * @return If the new <code>Node</code> replaces an existing node the
-	 *	 replaced <code>Node</code> is returned, 
-	 *	 otherwise <code>null</code> is returned.
-	 * @exception DOMException
-	 *	 WRONG_DOCUMENT_ERR: Raised if <code>arg</code> was created from a 
-	 *	 different document than the one that created the 
-	 *	 <code>NamedNodeMap</code>.
-	 *	 <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this 
-	 *	 <code>NamedNodeMap</code> is readonly.
-	 *	 <br>INUSE_ATTRIBUTE_ERR: Raised if <code>arg</code> is an 
-	 *	 <code>Attr</code> that is already an attribute of another 
-	 *	 <code>Element</code> object. The DOM user must explicitly clone 
-	 *	 <code>Attr</code> nodes to re-use them in other elements.
-	 */
-	virtual XalanNode*
-	setNamedItem(XalanNode* 	arg);
-
-	/**
-	 * Returns the <code>index</code>th item in the map. 
-	 *
-	 * If <code>index</code> 
-	 * is greater than or equal to the number of nodes in the map, this returns 
-	 * <code>null</code>.
-	 * @param index Index into the map.
-	 * @return The node at the <code>index</code>th position in the 
-	 *	 <code>NamedNodeMap</code>, or <code>null</code> if that is not a valid 
-	 *	 index.
-	 */
-	virtual XalanNode*
-	item(unsigned int	index) const;
-
-	//@}
-	/** @name Get functions. */
-	//@{
-
-	/**
-	 * Retrieves a node specified by name.
-	 *
-	 * @param name The <code>nodeName</code> of a node to retrieve.
-	 * @return A <code>DOM_Node</code> (of any type) with the specified <code>nodeName</code>, or 
-	 *	 <code>null</code> if it does not identify any node in 
-	 *	 the map. 
-	 */
-	virtual XalanNode*
-	getNamedItem(const XalanDOMString& 	name) const;
-
-	/**
-	 * The number of nodes in the map. 
-	 *
-	 * The range of valid child node indices is 
-	 * 0 to <code>length-1</code> inclusive. 
-	 */
-	virtual unsigned int
-	getLength() const;
-
-	//@}
-	/** @name Functions to change the node collection. */
-	//@{
-
-	/**
-	* Removes a node specified by name.
-	*
-	* If the removed node is an 
-	* <code>Attr</code> with a default value it is immediately replaced.
-	* @param name The <code>nodeName</code> of a node to remove.
-	* @return The node removed from the map or <code>null</code> if no node 
-	*	with such a name exists.
-	* @exception DOMException
-	*	NOT_FOUND_ERR: Raised if there is no node named <code>name</code> in 
-	*	the map.
-	* <br>
-	*	NO_MODIFICATION_ALLOWED_ERR: Raised if this <code>NamedNodeMap</code>
-	*	is readonly.
-	*/
-	virtual XalanNode*
-	removeNamedItem(const XalanDOMString&	name);
-
-	//@}
-	/** @name Functions introduced in DOM Level 2. */
-	//@{
-
-	/**
-	 * Retrieves a node specified by local name and namespace URI.
-	 *
-	 * @param namespaceURI The <em>namespace URI</em> of
-	 *	  the node to retrieve.
-	 * @param localName The <em>local name</em> of the node to retrieve.
-	 * @return A <code>DOM_Node</code> (of any type) with the specified
-	 *	  local name and namespace URI, or <code>null</code> if they do not
-	 *	  identify any node in the map.
-	 */
-	virtual XalanNode*
-	getNamedItemNS(
-			const XalanDOMString&	namespaceURI,
-			const XalanDOMString&	localName) const;
-
-	/**
-	 * Adds a node using its <CODE>namespaceURI</CODE> and <CODE>localName</CODE>.
-	 * @param arg A node to store in a named node map. The node will later be 
-	 *		 accessible using the value of the <CODE>namespaceURI</CODE> and 
-	 *		 <CODE>localName</CODE> attribute of the node. If a node with those 
-	 *		 namespace URI and local name is already present in the map, it is 
-	 *		 replaced by the new one.
-	 * @return If the new <code>Node</code> replaces an existing node the
-	 *	 replaced <code>Node</code> is returned, 
-	 *	 otherwise <code>null</code> is returned.
-	 * @exception DOMException
-	 *	 WRONG_DOCUMENT_ERR: Raised if <code>arg</code> was created from a 
-	 *	 different document than the one that created the 
-	 *	 <code>NamedNodeMap</code>.
-	 *	 <br>NO_MODIFICATION_ALLOWED_ERR: Raised if this 
-	 *	 <code>NamedNodeMap</code> is readonly.
-	 *	 <br>INUSE_ATTRIBUTE_ERR: Raised if <code>arg</code> is an 
-	 *	 <code>Attr</code> that is already an attribute of another 
-	 *	 <code>Element</code> object. The DOM user must explicitly clone 
-	 *	 <code>Attr</code> nodes to re-use them in other elements.
-	 */
-	virtual XalanNode*
-	setNamedItemNS(XalanNode*	arg);
-
-	/**
-	 * Removes a node specified by local name and namespace URI.
-	 *
-	 * @param namespaceURI The <em>namespace URI</em> of
-	 *	  the node to remove.
-	 * @param localName The <em>local name</em> of the
-	 *	  node to remove. When this <code>DOM_NamedNodeMap</code> contains the
-	 *	  attributes attached to an element, as returned by the attributes
-	 *	  attribute of the <code>DOM_Node</code> interface, if the removed
-	 *	  attribute is known to have a default value, an attribute
-	 *	  immediately appears containing the default value
-	 *	  as well as the corresponding namespace URI, local name, and prefix.
-	 * @return The node removed from the map if a node with such a local name
-	 *	  and namespace URI exists.
-	 * @exception DOMException
-	 *	 NOT_FOUND_ERR: Raised if there is no node named <code>name</code> in 
-	 *	 the map.
-	 * <br>
-	 *	 NO_MODIFICATION_ALLOWED_ERR: Raised if this <code>NamedNodeMap</code>
-	 *	 is readonly.
-	 */
-	virtual XalanNode*
-	removeNamedItemNS(
-			const XalanDOMString&	namespaceURI,
-			const XalanDOMString&	localName);
-
-	//@}
-
-private:
-
-	// Not implemented...
-	XercesNamedNodeMapBridge(const XercesNamedNodeMapBridge&	theSource);
-
-	XercesNamedNodeMapBridge&
-	operator=(const XercesNamedNodeMapBridge&	theRHS);
-
-	bool
-	operator==(const XercesNamedNodeMapBridge&	theRHS) const;
-
-
-	// $$$ ToDo:  Eventually, this will not need to be mutable.
-	mutable DOM_NamedNodeMap		m_xercesNamedNodeMap;
-
-	const XercesBridgeNavigator&	m_navigator;
-};
-
-
-
-#endif	// !defined(XERCESNAMEDNODEMAPBRIDGE_HEADER_GUARD_1357924680)
diff --git a/src/XercesParserLiaison/XercesNodeListBridge.hpp b/src/XercesParserLiaison/XercesNodeListBridge.hpp
deleted file mode 100644
index 0311c73..0000000
--- a/src/XercesParserLiaison/XercesNodeListBridge.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 1999 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/>.
- */
-#if !defined(XERCESNODELISTBRIDGE_HEADER_GUARD_1357924680)
-#define XERCESNODELISTBRIDGE_HEADER_GUARD_1357924680
-
-
-
-#include <XercesParserLiaison/XercesParserLiaisonDefinitions.hpp>
-
-
-
-#include <dom/DOM_NodeList.hpp>
-
-
-
-#include <XalanDOM/XalanNodeList.hpp>
-
-
-
-class XercesBridgeNavigator;
-
-
-
-class XALAN_XERCESPARSERLIAISON_EXPORT XercesNodeListBridge : public XalanNodeList
-{
-public:
-
-	XercesNodeListBridge(
-			const DOM_NodeList&				theXercesNodeList,
-			const XercesBridgeNavigator&	theNavigator);
-
-	XercesNodeListBridge(const XercesNodeListBridge&	theSource);
-
-	virtual
-	~XercesNodeListBridge();
-
-	bool
-	operator==(const XercesNodeListBridge& 	theRHS) const
-	{
-		return m_xercesNodeList == theRHS.m_xercesNodeList ? true : false;
-	}
-
-	/** @name Get functions. */
-	//@{
-	/**
-	 * Returns the <code>index</code>th item in the collection. 
-	 *
-	 * If <code>index</code> is greater than or equal to the number of nodes in 
-	 * the list, this returns <code>null</code>.
-	 *
-	 * @param index Index into the collection.
-	 * @return The node at the <code>index</code>th position in the 
-	 *	 <code>NodeList</code>, or <code>null</code> if that is not a valid 
-	 *	 index.
-	 */
-	virtual XalanNode*
-	item(unsigned int	index) const;
-
-	/**
-	 * Returns the number of nodes in the list. 
-	 *
-	 * The range of valid child node indices is 0 to <code>length-1</code> inclusive. 
-	 */
-	virtual unsigned int
-	getLength() const;
-
-private:
-
-	// Not implemented...
-	XercesNodeListBridge&
-	operator=(const XercesNodeListBridge&	theRHS);
-
-
-	// Data members...
-	DOM_NodeList					m_xercesNodeList;
-
-	const XercesBridgeNavigator&	m_navigator;
-};
-
-
-
-#endif	// !defined(XERCESNODELISTBRIDGE_HEADER_GUARD_1357924680)
diff --git a/src/XercesParserLiaison/XercesTreeWalker.cpp b/src/XercesParserLiaison/XercesTreeWalker.cpp
deleted file mode 100644
index 6b1ef83..0000000
--- a/src/XercesParserLiaison/XercesTreeWalker.cpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * The Apache Software License, Version 1.1
- *
- *
- * Copyright (c) 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 "XercesTreeWalker.hpp"
-
-
-
-// Xerces header files...
-#include <dom/DOM_Node.hpp>
-
-
-
-XercesTreeWalker::XercesTreeWalker()
-{
-}
-
-
-
-XercesTreeWalker::~XercesTreeWalker()
-{
-}
-
-
-
-void
-XercesTreeWalker::traverse(const DOM_Node&	pos)
-{
-	DOM_Node	thePos(pos);
-
-	while(thePos != 0)
-	{
-		startNode(thePos);
-
-		DOM_Node	nextNode = thePos.getFirstChild();
-
-		while(nextNode == 0)
-		{
-			endNode(thePos);
-
-			nextNode = pos.getNextSibling();
-
-			if(nextNode == 0)
-			{
-				thePos = thePos.getParentNode();
-
-				if(thePos == 0)
-				{
-					nextNode = thePos;
-
-					break;
-				}
-			}
-		}
-
-		thePos = nextNode;
-	}
-}
-
-
-
-void
-XercesTreeWalker::traverse(
-			const DOM_Node&		pos,
-			const DOM_Node&		parent)
-{
-	DOM_Node	thePos(pos);
-
-	while(parent != thePos)
-	{	  
-		startNode(thePos);
-	  
-		DOM_Node	nextNode = thePos.getFirstChild();
-
-		while(nextNode == 0)
-		{
-			endNode(thePos);
-
-			nextNode = thePos.getNextSibling();
-
-			if(nextNode == 0)
-			{
-				thePos = thePos.getParentNode();
-
-				if(parent == thePos)
-				{
-					nextNode = thePos;
-
-					break;
-				}
-			}
-		}
-
-		thePos = nextNode;
-	}
-}
