diff --git a/Projects/Win32/VC6/PlatformSupport/PlatformSupport.dsp b/Projects/Win32/VC6/PlatformSupport/PlatformSupport.dsp
new file mode 100644
index 0000000..f6959f4
--- /dev/null
+++ b/Projects/Win32/VC6/PlatformSupport/PlatformSupport.dsp
@@ -0,0 +1,458 @@
+# Microsoft Developer Studio Project File - Name="PlatformSupport" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
+
+CFG=PlatformSupport - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "PlatformSupport.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "PlatformSupport.mak" CFG="PlatformSupport - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "PlatformSupport - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "PlatformSupport - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE "PlatformSupport - Win32 Release with symbols" (based on "Win32 (x86) Dynamic-Link Library")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+MTL=midl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "PlatformSupport - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\..\..\Build\Win32\VC6\Release"
+# PROP Intermediate_Dir "..\..\..\..\Build\Win32\VC6\Release\PlatformSupport"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "XALAN_PLATFORMSUPPORT_EXPORTS" /YX /FD /c
+# ADD CPP /nologo /MD /W4 /GR /GX /O2 /Ob2 /I "..\..\..\..\..\..\xml-xerces\c\src" /I "..\..\..\..\src\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "XALAN_PLATFORMSUPPORT_BUILD_DLL" /FD /I /xml4c/include" /I /xml4c/include" " " " " " " /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
+# ADD LINK32 ..\..\..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib /nologo /dll /pdb:none /machine:I386
+# SUBTRACT LINK32 /debug
+
+!ELSEIF  "$(CFG)" == "PlatformSupport - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\..\..\Build\Win32\VC6\Debug"
+# PROP Intermediate_Dir "..\..\..\..\Build\Win32\VC6\Debug\PlatformSupport"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "PlatformSupport_EXPORTS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /Gm /GR /GX /Zi /Od /I "..\..\..\..\..\..\xml-xerces\c\src" /I "..\..\..\..\src\\" /D "_WINDOWS" /D "_USRDLL" /D "XALAN_PLATFORMSUPPORT_BUILD_DLL" /D "WIN32" /D "_DEBUG" /D "_MBCS" /YX /FD /I /xml4c/include" /I /lotusxsl4c/stl" /I /lotusxsl4c/src/include" /I /xml4c/include" /GZ " " " " " " /c
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\..\..\..\..\xml-xerces\c\Build\Win32\VC6\Debug\xerces-c_1D.lib /nologo /dll /debug /machine:I386 /out:"..\..\..\..\Build\Win32\VC6\Debug/PlatformSupportD.dll" /pdbtype:sept
+
+!ELSEIF  "$(CFG)" == "PlatformSupport - Win32 Release with symbols"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "PlatformSupport___Win32_Release_with_symbols"
+# PROP BASE Intermediate_Dir "PlatformSupport___Win32_Release_with_symbols"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\..\..\Build\Win32\VC6\Release.symbols"
+# PROP Intermediate_Dir "..\..\..\..\Build\Win32\VC6\Release.symbols\PlatformSupport"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W4 /GR /GX /O2 /Ob2 /I "..\..\..\..\..\..\xml-xerces\c\src" /I "..\..\..\..\src\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "XALAN_PLATFORMSUPPORT_BUILD_DLL" /D "XALAN_XERCES" /FD /I /xml4c/include" /I /xml4c/include" " " " " " " /c
+# SUBTRACT BASE CPP /YX
+# ADD CPP /nologo /MD /W4 /GR /GX /Zi /O2 /Ob2 /I "..\..\..\..\..\..\xml-xerces\c\src" /I "..\..\..\..\src\\" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "XALAN_PLATFORMSUPPORT_BUILD_DLL" /D "XALAN_XERCES" /FD /I /xml4c/include" /I /xml4c/include" " " " " " " /c
+# SUBTRACT CPP /YX
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 ..\..\..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib /nologo /dll /pdb:none /machine:I386
+# SUBTRACT BASE LINK32 /debug
+# ADD LINK32 ..\..\..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib /nologo /dll /debug /machine:I386 /out:"..\..\..\..\Build\Win32\VC6\Release.symbols/PlatformSupportS.dll"
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "PlatformSupport - Win32 Release"
+# Name "PlatformSupport - Win32 Debug"
+# Name "PlatformSupport - Win32 Release with symbols"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributeListImpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributesImpl.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DOMStringHelper.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DOMStringPrintWriter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DoubleSupport.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ExecutionContext.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\FormatterListener.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\NamedNodeMapAttributeList.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\NullPrintWriter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PlatformSupportInit.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PrefixResolver.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PrintWriter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\Resettable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\StdBinInputStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\StringTokenizer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\URISupport.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\Writer.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanBitmap.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDecimalFormat.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDecimalFormatSymbols.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringCache.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringHashTable.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringPool.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanFileOutputStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanNullOutputStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanNumberFormat.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanOutputStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanOutputStreamPrintWriter.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanReferenceCountedObject.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanStdOutputStream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanToXercesTranscoderWrapper.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanTranscodingServices.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanUTF16Transcoder.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanXMLChar.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XSLException.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ArenaAllocator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ArenaBlock.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributeListImpl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributesImpl.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributeVectorEntry.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\AttributeVectorEntryExtended.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DirectoryEnumerator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DOMStringHelper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DOMStringPrintWriter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\DoubleSupport.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ExecutionContext.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\FormatterListener.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\NamedNodeMapAttributeList.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\NullPrintWriter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PlatformSupportDefinitions.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PlatformSupportInit.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PrefixResolver.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\PrintWriter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\Resettable.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ReusableArenaAllocator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\ReusableArenaBlock.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\StdBinInputStream.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\StringTokenizer.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\URISupport.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\Writer.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanAllocator.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanBitmap.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDecimalFormat.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDecimalFormatSymbols.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringCache.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringHashTable.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanDOMStringPool.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanFileOutputStream.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanNullOutputStream.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanNumberFormat.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanOutputStream.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanOutputStreamPrintWriter.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanReferenceCountedObject.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanStdOutputStream.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanToXercesTranscoderWrapper.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanTranscodingServices.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanUnicode.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanUTF16Transcoder.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XalanXMLChar.hpp
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\..\src\PlatformSupport\XSLException.hpp
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/Tests/Compare/compare.dsp b/Tests/Compare/compare.dsp
new file mode 100644
index 0000000..2065f7c
--- /dev/null
+++ b/Tests/Compare/compare.dsp
@@ -0,0 +1,149 @@
+# Microsoft Developer Studio Project File - Name="compare" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=compare - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "compare.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "compare.mak" CFG="compare - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "compare - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "compare - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE "compare - Win32 Release with symbols" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "compare - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\Build\Win32\VC6\Release"
+# PROP Intermediate_Dir "..\..\Build\Win32\VC6\Release\compare"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W4 /GR /GX /O2 /Ob2 /I "..\..\..\..\xml-xerces\c\src" /I "..\..\src\\" /I "..\harness\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 ..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib ..\..\Build\Win32\VC6\Release\*.lib /nologo /stack:0x1f4000 /subsystem:console /pdb:none /machine:I386
+
+!ELSEIF  "$(CFG)" == "compare - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "..\..\Build\Win32\VC6\Debug"
+# PROP Intermediate_Dir "..\..\Build\Win32\VC6\Debug\compare"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /MDd /W4 /GR /GX /Od /I "..\..\..\..\xml-xerces\c\src" /I "..\..\src\\" /I "..\harness\\" /D "_WINDOWS" /D "_CONSOLE" /D "WIN32" /D "_DEBUG" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 ..\..\..\..\xml-xerces\c\Build\Win32\VC6\Debug\xerces-c_1D.lib ..\..\Build\Win32\VC6\Debug\*.lib /nologo /stack:0x1f4000 /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ELSEIF  "$(CFG)" == "compare - Win32 Release with symbols"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "compare___Win32_Release_with_symbols"
+# PROP BASE Intermediate_Dir "compare___Win32_Release_with_symbols"
+# PROP BASE Ignore_Export_Lib 0
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "..\..\Build\Win32\VC6\Release.symbols"
+# PROP Intermediate_Dir "..\..\Build\Win32\VC6\Release.symbols\compare"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\..\xml-xerces\c\src" /I "..\..\src\\" /I "..\harness\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /MD /W4 /GR /GX /Zi /O2 /Ob2 /I "..\..\..\..\xml-xerces\c\src" /I "..\..\src\\" /I "..\harness\\" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /FD /c
+# SUBTRACT CPP /YX
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 ..\..\Build\Win32\VC6\Release\Harness.lib ..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib ..\..\Build\Win32\VC6\Release\*.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386 /out:"..\..\Build\Win32\VC6\Release/perft.exe"
+# ADD LINK32 ..\..\..\..\xml-xerces\c\Build\Win32\VC6\Release\xerces-c_1.lib ..\..\Build\Win32\VC6\Release.symbols\*.lib /nologo /stack:0x1f4000 /subsystem:console /debug /machine:I386 /fixed:no
+# SUBTRACT LINK32 /pdb:none
+
+!ENDIF 
+
+# Begin Target
+
+# Name "compare - Win32 Release"
+# Name "compare - Win32 Debug"
+# Name "compare - Win32 Release with symbols"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\compare.cpp
+
+!IF  "$(CFG)" == "compare - Win32 Release"
+
+# ADD CPP /MD /Zi
+
+!ELSEIF  "$(CFG)" == "compare - Win32 Debug"
+
+# PROP Intermediate_Dir "..\..\Build\Win32\VC6\Debug\compare"
+# ADD CPP /MDd /Zi
+
+!ELSEIF  "$(CFG)" == "compare - Win32 Release with symbols"
+
+# ADD BASE CPP /MD /Zi
+# ADD CPP /MD /Zi
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
diff --git a/Tests/Tests.dsw b/Tests/Tests.dsw
new file mode 100644
index 0000000..4719fc2
--- /dev/null
+++ b/Tests/Tests.dsw
@@ -0,0 +1,170 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "Harness"=".\Harness\Harness.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "Memory"=".\Memory\Memory.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "Params"=".\Params\Params.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "PerfT"=".\PerfT\PerfT.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "ThreadTest"=".\Threads\ThreadTest.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "Transformer"=".\Transformer\Transformer.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "compare"=".\Compare\compare.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "dom2dom"=".\Dom2Dom\Dom2Dom.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "extensions"=".\Extensions\extensions.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "inputsource"=".\InputSource\inputsource.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "perf"=".\Performance\perf.dsp" - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name Harness
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/Tests/Threads/ThreadTest.cpp b/Tests/Threads/ThreadTest.cpp
new file mode 100644
index 0000000..e4ad5a3
--- /dev/null
+++ b/Tests/Threads/ThreadTest.cpp
@@ -0,0 +1,402 @@
+// Base header file.  Must be first.
+#include <Include/PlatformDefinitions.hpp>
+
+
+
+#include <cassert>
+#include <ctime>
+
+
+
+#if defined(XALAN_OLD_STREAM_HEADERS)
+#include <iostream.h>
+#else
+#include <iostream>
+#endif
+
+
+
+#include <util/PlatformUtils.hpp>
+#include <util/Mutexes.hpp>
+
+
+
+#include <Include/XalanAutoPtr.hpp>
+
+
+
+#include <XalanTransformer/XalanTransformer.hpp>
+
+
+
+#if defined(WIN32)
+//This is here for the threads.
+#include <process.h>
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(XALAN_POSIX2_AVAILABLE)
+#include <pthread.h>
+#include <unistd.h>
+#else
+#error Unsupported platform!
+#endif
+
+
+
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::cerr;
+	using std::cout;
+	using std::endl;
+#endif
+
+
+	
+// This is here for memory leak testing.
+#if defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+
+	
+class SynchronizedCounter
+{
+public:
+
+	SynchronizedCounter();
+
+	~SynchronizedCounter();
+
+	void
+	increment();
+
+	void
+	decrement();
+
+	unsigned long
+	getCounter() const;
+
+private:
+
+	mutable XMLMutex	m_mutex;
+
+	unsigned long		m_counter;
+};
+
+
+
+SynchronizedCounter::SynchronizedCounter() :
+	m_mutex(),
+	m_counter(0)
+{
+}
+
+
+
+SynchronizedCounter::~SynchronizedCounter()
+{
+}
+
+
+
+void
+SynchronizedCounter::increment()
+{
+	XMLMutexLock	theLock(&m_mutex);
+
+	if (m_counter < ULONG_MAX)
+	{
+		++m_counter;
+	}
+}
+
+
+
+void
+SynchronizedCounter::decrement()
+{
+	XMLMutexLock	theLock(&m_mutex);
+
+	if (m_counter > 0)
+	{
+		--m_counter;
+	}
+}
+
+
+
+unsigned long
+SynchronizedCounter::getCounter() const
+{
+	return m_counter;
+}
+
+
+
+struct
+ThreadInfo
+{
+	ThreadInfo(
+			unsigned int			theThreadNumber = 0,
+			SynchronizedCounter*	theCounter = 0) :
+		m_threadNumber(theThreadNumber),
+		m_counter(theCounter)
+	{
+	}
+
+	unsigned int			m_threadNumber;
+
+	SynchronizedCounter*	m_counter;
+};
+
+
+
+// Used to hold compiled stylesheet and pre-parsed source...
+const XalanCompiledStylesheet*	glbCompiledStylesheet = 0;
+const XalanParsedSource*		glbParsedSource = 0;
+
+
+
+#if defined(WIN32)
+
+extern "C" void theThreadRoutine(void* param);
+
+void
+#elif defined(XALAN_POSIX2_AVAILABLE)
+
+extern "C" void* theThreadRoutine(void* param);
+
+void*
+#else
+#error Unsupported platform!
+#endif
+theThreadRoutine(void*		param)
+{
+// This routine uses compiled stylesheet (glbStylesheetRoot), which is set using the 
+// theProcessor.setStylesheetRoot method. The transform is done using the theProcessor's
+// process() method.
+
+#if defined(XALAN_OLD_STYLE_CASTS)
+	const ThreadInfo* const		theInfo = (const ThreadInfo*)param;
+#else
+	const ThreadInfo* const		theInfo = reinterpret_cast<const ThreadInfo*>(param);
+#endif
+
+	assert(theInfo != 0);
+
+	theInfo->m_counter->increment();
+
+	try
+	{
+		// Our input file.  The assumption is that the executable will be run
+		// from same directory as the input files.
+
+		// Generate the output file name.
+		const XalanDOMString	theOutputFile(
+				XalanDOMString("birds") +
+				UnsignedLongToDOMString(theInfo->m_threadNumber) +
+				XalanDOMString(".out"));
+
+		// Create a transformer...
+		XalanTransformer	theTransformer;
+
+		// Do the transform...
+		theTransformer.transform(*glbParsedSource, glbCompiledStylesheet, XSLTResultTarget(theOutputFile));
+	}
+	catch(...)
+	{
+		cerr << "Exception caught in thread " << theInfo->m_threadNumber;
+	}
+
+	// Decrement the counter because we're done...
+	theInfo->m_counter->decrement();
+
+#if defined(XALAN_POSIX2_AVAILABLE)
+	return 0;
+#endif
+}
+
+
+
+inline void
+doSleep(unsigned int	theMilliseconds)
+{
+#if defined(WIN32)
+	Sleep(theMilliseconds);
+#elif defined(XALAN_POSIX2_AVAILABLE)
+	usleep(theMilliseconds * 10);
+#else
+#error Unsupported platform!
+#endif
+}
+
+
+
+void
+doThreads(long	theThreadCount)
+{
+	cout << endl << "Starting " << theThreadCount << " threads." << endl;
+
+	XalanArrayAutoPtr<ThreadInfo>	theThreadInfo(new ThreadInfo[theThreadCount]);
+
+	try
+	{
+		cout << endl << "Clock before starting threads: " << clock() << endl;
+
+		SynchronizedCounter		theCounter;
+
+		long	i = 0;
+
+		while (i < theThreadCount)
+		{
+			theThreadInfo[i].m_threadNumber = i;
+			theThreadInfo[i].m_counter = &theCounter;
+
+#if defined(WIN32)
+
+			const unsigned long		theThreadID =
+					_beginthread(theThreadRoutine, 4096, reinterpret_cast<LPVOID>(&theThreadInfo[i]));
+
+			if (theThreadID == unsigned(-1))
+			{
+				cerr << endl << "Unable to create thread number " << i + 1 << "." << endl;
+			}
+
+#elif defined(XALAN_POSIX2_AVAILABLE)
+
+			pthread_t	theThread;
+
+			const int	theResult = pthread_create(&theThread, 0, theThreadRoutine, (void*)&theThreadInfo[i]);
+
+			if (theResult != 0)
+			{
+				cerr << endl << "Unable to create thread number " << i + 1 << "." << endl;
+			}
+			else
+			{
+#if defined(OS390)
+				pthread_detach(&theThread);
+#else
+				pthread_detach(theThread);
+#endif
+			}
+#else
+#error Unsupported platform!
+#endif
+
+			++i;
+		}
+
+		clock_t		theClock = 0;
+
+		if (i == 0)
+		{
+			cerr << endl << "No threads were created!" << endl;
+		}
+		else
+		{
+			unsigned int	theCheckCount = 0;
+
+			do
+			{
+				doSleep(2000);
+
+				// Check a couple of times, just in case, since
+				// getCounter() is not synchronized...
+				if (theCounter.getCounter() == 0)
+				{
+					if (theCheckCount == 0)
+					{
+						theClock = clock();
+					}
+
+					++theCheckCount;
+				}
+			}
+			while(theCheckCount < 2);
+		}
+
+		cout << endl << "Clock after threads: " << theClock << endl;
+	}
+	catch(...)
+	{
+		cerr << "Exception caught!!!"
+			 << endl
+			<< endl;
+	}
+}
+
+
+int
+main(
+			int				argc,
+			const char*		argv[])
+{
+#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
+
+	if (argc > 2)
+	{
+		cerr << "Usage: ThreadTest"
+			 << endl
+			 << endl;
+	}
+	else
+	{
+		int		threadCount = 60;
+
+		if (argc == 2)
+		{
+			threadCount = atoi(argv[1]);
+		}
+
+		try
+		{
+			// Initialize Xerces...
+			XMLPlatformUtils::Initialize();
+
+			// Initialize Xalan...
+			XalanTransformer::initialize();
+
+			{
+				// Create a XalanTransformer.  We won't actually use this to transform --
+				// it's just acting likely a factory for the compiled stylesheet and
+				// pre-parsed source.
+				XalanTransformer	theXalanTransformer;
+
+				const char* const	theXSLFileName = "birds.xsl";
+
+				theXalanTransformer.compileStylesheet(theXSLFileName, glbCompiledStylesheet);
+				assert(glbCompiledStylesheet != 0);
+
+				// Compile the XML source document as well. All threads will use
+				// this binary representation of the source tree.
+				const char* const	theXMLFileName = "birds.xml";
+
+				theXalanTransformer.parseSource(theXMLFileName, glbParsedSource);
+				assert(glbParsedSource != 0);
+
+				doThreads(threadCount);
+			}
+
+			// Terminate Xalan...
+			XalanTransformer::terminate();
+
+			// Terminate Xerces...
+			XMLPlatformUtils::Terminate();
+		}
+		catch(...)
+		{
+			cerr << "Exception caught!!!"
+				 << endl
+				 << endl;
+		}
+
+	} 
+
+	return 0;
+}
diff --git a/src/Makefile.in b/src/Makefile.in
new file mode 100644
index 0000000..fb94606
--- /dev/null
+++ b/src/Makefile.in
@@ -0,0 +1,664 @@
+#
+# 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", "Xerces" 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/>.
+# 
+###################################################################
+#                    IMPORTANT NOTE                               #
+###################################################################
+# Before you try to run the Makefile, make sure you have two      #
+# environment variables set.                                      #
+#                                                                 #
+# export XALANCROOT=<the directory where you installed XALAN-C>   #
+# export XERCESCROOT=<the directory where you installed XERCES-C> #
+#                                                                 #
+###################################################################
+
+DEPFILE=depends
+
+#MACROS defining commands
+MKDIR=mkdir
+
+ifndef XALANCROOT 
+noxalanroot:
+	@echo XALANCROOT must be defined
+endif
+
+ifndef XERCESCROOT 
+noxercesroot:
+	@echo XERCESCROOT must be defined
+endif
+
+ifdef XALAN_USE_ICU
+ifndef ICUROOT
+ICUROOT=/usr/local
+endif
+ifndef ICUI18NROOT
+ICUI18NROOT=${ICUROOT}
+endif
+endif
+
+XALANDOM_DIR = XalanDOM
+DOMSUPPORT_DIR = DOMSupport
+INCLUDE_DIR = Include
+ICUBRIDGE_DIR = ICUBridge
+PLATFORMSUPPORT_DIR = PlatformSupport
+XALANSOURCETREE_DIR = XalanSourceTree
+TESTXPATH_DIR = TestXPath
+TESTXSLT_DIR = TestXSLT
+XMLSUPPORT_DIR = XMLSupport
+XPATH_DIR = XPath
+XSLT_DIR = XSLT
+XALANEXTENSIONS_DIR = XalanExtensions
+XERCESPARSERLIAISON_DIR = XercesParserLiaison
+XALANTRANSFORMER_DIR = XalanTransformer
+ALL_OBJECTS_DIR = ${XALANCROOT}/obj
+LIB_DIR = ${XALANCROOT}/lib
+SAMPLES_DIR = ${XALANCROOT}/samples
+TESTS_DIR = ${XALANCROOT}/Tests
+
+PROJECT_NAME = xalan-c
+LIBNAME = lib${PROJECT_NAME}
+THISLIB = ${LIB_DIR}/${LIBNAME}
+VER = 1_2
+
+PRODUCTNAME=xalan
+PRODUCTVERSION=${VER}
+BINTARGETDIR=${XALANCROOT}/bin
+
+ALL_VPATH_CPP = \
+$(XALANDOM_DIR):$(DOMSUPPORT_DIR):$(PLATFORMSUPPORT_DIR):$(XALANSOURCETREE_DIR):$(TESTXPATH_DIR):$(TESTXSLT_DIR):\
+$(XMLSUPPORT_DIR):$(XPATH_DIR):$(XSLT_DIR):$(XALANEXTENSIONS_DIR):$(XALANTRANSFORMER_DIR):$(XERCESPARSERLIAISON_DIR)
+
+# Using ICUBridge
+ifdef XALAN_USE_ICU
+ALL_VPATH_CPP+=:$(ICUBRIDGE_DIR)
+endif
+
+#all these setting come from the arguments passed in to runConfigure.
+PLATFORM =@platform@
+CC  = @cc@
+CXX = @cxx@
+CXXFLAGS = @cxxflags@
+PREFIX = @prefix@
+
+#=============== LINUX SPECIFIC OPTIONS =========================
+
+ifeq ($(PLATFORM), LINUX)
+
+  SUPPORTED = TRUE
+  PLATFORM_COMPILE_OPTIONS = -fpic -Wall -instances=static -D${PLATFORM} -D_REENTRANT
+  ALLLIBS = ${LIBS} -L/usr/lib
+  SHLIBSUFFIX=.so
+
+  # We need the ICU library if we are using the ICUBridge
+  ifdef XALAN_USE_ICU
+  LD_RPATH_PRE=	-Wl,-rpath,
+  PLATFORM_LIB_LINK_OPTIONS=$(LD_RPATH_PRE)${ICUROOT}/lib 
+  endif
+
+  EXTRA_LINK_OPTIONS=-lc
+  CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+  MAKE_SHARED = ${CXX} $(CXXFLAGS) -D${PLATFORM} -shared -fpic
+  LINK =  g++ -D${PLATFORM} -fpic
+
+endif
+
+#=============== HPUX SPECIFIC OPTIONS =========================
+
+ifeq ($(PLATFORM), HPUX)
+
+  SUPPORTED = TRUE
+  PLATFORM_COMPILE_OPTIONS = +Z -D${PLATFORM} -D_THREAD_SAFE
+  ALLLIBS = ${LIBS}
+  SHLIBSUFFIX=.sl
+  CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+  CC2 = $(CXX) $(PLATFORM_COMPILE_OPTIONS)
+  MAKE_SHARED = $(CXX) -b +Z
+  LINK = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS) -Wl,+s
+
+endif
+
+#=============== SOLARIS SPECIFIC OPTIONS =========================
+
+ifeq ($(PLATFORM), SOLARIS)
+
+  SUPPORTED = TRUE
+
+  ifeq (${CXX}, g++)
+
+	PLATFORM_COMPILE_OPTIONS = -fPIC -instances=static -D${PLATFORM} -D_REENTRANT
+	ALLLIBS = ${LIBS} -L/usr/lib -L/usr/local/lib -lc
+
+	ifdef XALAN_USE_ICU
+	LD_RPATH_PRE=  -Wl,-rpath,
+	endif
+
+	EXTRA_LINK_OPTIONS=-lc
+	CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+	MAKE_SHARED = ${CXX} $(CXXFLAGS) -D${PLATFORM} -shared -fPIC
+	LINK =  g++ -D${PLATFORM} -fPIC
+
+	ALLLIBS = ${LIBS} -L/usr/lib -L/usr/local/lib -lc
+
+    PLATFORM_LIB_LINK_OPTIONS=$(LD_RPATH_PRE)${ICUROOT}/lib $(LD_RPATH_PRE)${ICUI18NROOT}/lib
+
+  else
+
+	PLATFORM_COMPILE_OPTIONS = -KPIC -mt -xs -ptr$(ALL_OBJECTS_DIR) -features=rtti -D${PLATFORM} -D_REENTRANT
+
+	CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS) -I${STLPORTROOT}/stlport
+    MAKE_SHARED = ${CXX} -D${PLATFORM} -G -ptr$(ALL_OBJECTS_DIR) ${LDFLAGS}
+    MAKE_SHARED_C = ${CC} -D${PLATFORM} -G ${LDFLAGS}
+	LINK = ${CXX} -D${PLATFORM} -ptr$(ALL_OBJECTS_DIR) ${LDFLAGS}
+
+    ALLLIBS = -mt ${LIBS} -L/usr/local/SUNWspro/lib -L/usr/ccs/lib \
+                  -lc -lgen
+  endif
+
+  SHLIBSUFFIX=.so
+
+endif
+
+#=============== AIX SPECIFIC OPTIONS =========================
+ifeq ($(PLATFORM), AIX)
+
+  SUPPORTED = TRUE
+
+  ifeq (${CXX}, g++)
+
+	PLATFORM_COMPILE_OPTIONS = -fPIC -instances=static -D${PLATFORM} -D_REENTRANT
+	ALLLIBS = ${LIBS} -L/usr/lib -L/usr/local/lib -lc
+
+	ifdef XALAN_USE_ICU
+	LD_RPATH_PRE=  -Wl,-rpath,
+	PLATFORM_LIB_LINK_OPTIONS=$(LD_RPATH_PRE)${ICUROOT}/lib $(LD_RPATH_PRE)${ICUI18NROOT}/lib
+	endif
+
+	EXTRA_LINK_OPTIONS=-lc
+	CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+	MAKE_SHARED = ${CXX} $(CXXFLAGS) -D${PLATFORM} -shared -fPIC
+	LINK =  g++ -D${PLATFORM} -fPIC
+
+	ALLLIBS = ${LIBS} -L/usr/lib -L/usr/local/lib -lc
+
+  else
+
+	ifndef STLPORTROOT 
+	nostlportroot:
+		@echo STLPORTROOT must be defined
+	endif
+
+	PLATFORM_COMPILE_OPTIONS = -D${PLATFORM} -D_THREAD_SAFE -I${STLPORTROOT}/stlport
+	ALLLIBS = ${LIBS} -L/usr/lib 
+	CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+	CC2 = $(CXX) $(PLATFORM_COMPILE_OPTIONS)
+	MAKE_SHARED = makeC++SharedLib_r -p 5000 
+	LINK = $(CXX) -qnotempinc $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+
+  endif
+
+  SHLIBSUFFIX=.a
+
+endif
+
+#=============== OS390 SPECIFIC OPTIONS =========================
+
+ifeq ($(PLATFORM), OS390)
+
+  ifndef STLPORTROOT
+  nostlportroot:
+	  @echo STLPORTROOT must be defined
+  endif
+
+  SUPPORTED = TRUE
+  PLATFORM_COMPILE_OPTIONS =-Wc,dll -W0,"langlvl(extended),float(ieee)" -D${PLATFORM} -D_OPEN_THREADS -D_XOPEN_SOURCE_EXTENDED -I ${STLPORTROOT}/stlport
+  PLATFORM_COMPILE_OPTIONS2 =-Wc,dll -W0,"langlvl(extended),notempinc,float(ieee)" -D${PLATFORM} -D_OPEN_THREADS -D_XOPEN_SOURCE_EXTENDED -I ${STLPORTROOT}/stlport
+  ALLLIBS =
+  SHLIBSUFFIX=.dll
+  OS390SIDEDECK=.x
+
+  CC1 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+  CC2 = $(CXX) $(PLATFORM_COMPILE_OPTIONS2)
+  CC3 = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS2)
+  MAKE_SHARED = ${CXX} $(CXXFLAGS) -D${PLATFORM} -Wl,dll
+  LINK = $(CXX) $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+
+endif
+
+#============ TRU64 SPECIFIC OPTIONS ============================
+
+ifeq ($(PLATFORM), TRU64)
+
+  SUPPORTED = TRUE
+  PLATFORM_COMPILE_OPTIONS = -D${PLATFORM} -ptr ${ALL_OBJECTS_DIR}/.cxx_repository -ieee -pthread
+  ALLLIBS = ${LIBS} -L/usr/lib -lc -lrt -lm
+  SHLIBSUFFIX = .so
+  CC1 = ${CXX} ${CXXFLAGS} $(PLATFORM_COMPILE_OPTIONS)
+  MAKE_SHARED = ${CXX} ${CXXFLAGS} -shared -D${PLATFORM} -ptr ${ALL_OBJECTS_DIR}/.cxx_repository -nocxxstd
+  LINK = ${CXX} $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+
+endif
+
+#============ MacOSX SPECIFIC OPTIONS ============================
+
+ifeq ($(PLATFORM), MACOSX)
+
+  SUPPORTED = TRUE
+  PLATFORM_COMPILE_OPTIONS = -Wall -D${PLATFORM} -D_REENTRANT -DXALAN_USE_XERCES_LOCAL_CODEPAGE_TRANSCODERS
+  ALLLIBS = ${LIBS} -L/usr/lib -L/usr/local/lib
+  SHLIBSUFFIX=.dylib
+  CC1 = ${CXX} $(CXXFLAGS) $(PLATFORM_COMPILE_OPTIONS)
+  MAKE_SHARED = ${CXX} $(CXXFLAGS) -D${PLATFORM} -dynamiclib
+  LINK = ${CXX} $(CXXFLAGS) ${PLATFORM_COMPILE_OPTIONS}
+
+endif
+
+ifndef SUPPORTED
+  nogood:
+	  @echo Linux, Solaris, AIX, Compaq Tru64, OS/390, MacOSX, and HP-UX are the only platforms supported.
+endif
+
+# We need the Xerces library
+ifeq ($(PLATFORM), OS390)
+  ALLLIBS += $(XERCESCROOT)/lib/libxerces-c1_5_1.x
+else
+  ALLLIBS += -L$(XERCESCROOT)/lib -lxerces-c1_5
+endif
+
+# We need the ICU library if we are using the ICUBridge
+ifdef XALAN_USE_ICU
+  ifeq ($(PLATFORM), OS390)
+    ALLLIBS += ${ICUROOT}/lib/libicuuc.x ${ICUROOT}/lib/libicui18n.x
+  else
+    ALLLIBS += -L${ICUROOT}/lib -licuuc
+    ALLLIBS += -L${ICUI18NROOT}/lib -licui18n
+  endif
+endif
+
+
+# We have to use the includes from the source distribution, since we use
+# headers that others normally wouldn't
+ifdef XALAN_USE_ICU
+# We need the ICU library if we are using the ICUBridge
+  XSL_INCL = -I${ICUROOT}/include/ -I. -I$(XERCESCROOT)/src/ -I$(XERCESCROOT)/include/ 
+  XSL_BUILD_OPTIONS += -DXALAN_USE_ICU
+else
+  XSL_INCL = -I. -I$(XERCESCROOT)/src/ -I$(XERCESCROOT)/include/ 
+endif
+
+
+vpath %.cpp \
+$(ALL_VPATH_CPP)
+${ALL_OBJECTS_DIR}/%.o:%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+
+${ALL_OBJECTS_DIR}/%.o:%.hpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $(patsubst .hpp,.cpp,$<)
+
+
+ALLSOURCE = \
+	$(wildcard $(XALANDOM_DIR)/*.cpp) \
+	$(wildcard $(DOMSUPPORT_DIR)/*.cpp) \
+	$(wildcard $(PLATFORMSUPPORT_DIR)/*.cpp) \
+	$(wildcard $(XALANSOURCETREE_DIR)/*.cpp) \
+	$(wildcard $(XMLSUPPORT_DIR)/*.cpp) \
+	$(wildcard $(XPATH_DIR)/*.cpp) \
+	$(wildcard $(XSLT_DIR)/*.cpp) \
+	$(wildcard $(XALANEXTENSIONS_DIR)/*.cpp) \
+	$(wildcard $(XERCESINIT_DIR)/*.cpp) \
+	$(wildcard $(XERCESPARSERLIAISON_DIR)/*.cpp) \
+	$(wildcard $(XALANTRANSFORMER_DIR)/*.cpp) \
+
+
+# Using ICUBridge
+ifdef XALAN_USE_ICU
+ALLSOURCE += \
+	$(wildcard $(ICUBRIDGE_DIR)/*.cpp) 
+endif
+
+ALL_OBJECTS = $(addprefix $(ALL_OBJECTS_DIR)/,$(addsuffix .o,$(basename $(notdir $(ALLSOURCE)))))
+
+all:	 lib  testXSLT testXPath
+
+prepare:
+	@echo Preparing the directory structure for a build ...
+	-${MKDIR} -p ${ALL_OBJECTS_DIR}
+	-${MKDIR} -p ${LIB_DIR}
+	-${MKDIR} -p $(BINTARGETDIR)
+
+# Create header dependencies file -- this must be run before any objects are
+# built
+depend:
+	$(MAKE) -f makedepends DEPFILE=$(DEPFILE)
+
+-include $(DEPFILE)	
+
+compile:	 $(ALL_OBJECTS) 
+
+ifeq ($(PLATFORM), AIX)
+templates: ${ALL_OBJECTS_DIR}/XalanTemplate.o
+
+${ALL_OBJECTS_DIR}/XalanTemplate.o:$(XSLT_DIR)/XalanTemplate.cpp
+	$(CC2) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) -o $@ $<
+else
+ifeq ($(PLATFORM), OS390)
+templates: ${ALL_OBJECTS_DIR}/XalanTemplate.o
+${ALL_OBJECTS_DIR}/XalanTemplate.o:$(XSLT_DIR)/XalanTemplate.cpp
+	$(CC2) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) -o $@ $<
+endif
+endif
+
+testXSLT: lib  $(BINTARGETDIR)/testXSLT
+
+ifeq ($(PLATFORM), OS390)                                                       
+$(BINTARGETDIR)/testXSLT: ${ALL_OBJECTS_DIR}/process.o                          
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $^ -o $@	
+${ALL_OBJECTS_DIR}/process.o: $(TESTXSLT_DIR)/process.cpp                       
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else                                                            
+$(BINTARGETDIR)/testXSLT: ${ALL_OBJECTS_DIR}/process.o
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $^ -o $@	
+${ALL_OBJECTS_DIR}/process.o: $(TESTXSLT_DIR)/process.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+testXPath: lib  $(BINTARGETDIR)/testXPath
+
+ifeq ($(PLATFORM), OS390)                                                       
+$(BINTARGETDIR)/testXPath: ${ALL_OBJECTS_DIR}/TestXPath.o ${ALL_OBJECTS_DIR}/NodeNameTreeWalker.o
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/TestXPath.o: $(TESTXPATH_DIR)/TestXPath.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+${ALL_OBJECTS_DIR}/NodeNameTreeWalker.o: $(TESTXPATH_DIR)/NodeNameTreeWalker.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else                                                                 
+$(BINTARGETDIR)/testXPath: ${ALL_OBJECTS_DIR}/TestXPath.o ${ALL_OBJECTS_DIR}/NodeNameTreeWalker.o
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(TESTXPATH_DIR)/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+samples : Samples
+
+tests : ThreadTest
+
+Samples: lib CompileStylesheet DocumentBuilder ExternalFunction SimpleTransform SimpleXPathAPI StreamTransform TraceListen UseStylesheetParam XalanTransform XalanTransformerCallback XPathWrapper
+
+ApacheModuleXSLT: lib ${LIB_DIR}/mod_xslt$(SHLIBSUFFIX) 
+
+${LIB_DIR}/mod_xslt$(SHLIBSUFFIX) : ${ALL_OBJECTS_DIR}/mod_xslt.o
+ifeq ($(PLATFORM), OS390)                                                       
+	$(MAKE_SHARED) $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x  $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/ApacheModuleXSLT/%.c
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) -I/usr/include/apache/ $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	$(MAKE_SHARED) $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/ApacheModuleXSLT/%.c
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) -I/usr/include/apache/ $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+CompileStylesheet: lib $(BINTARGETDIR)/CompileStylesheet
+
+$(BINTARGETDIR)/CompileStylesheet: ${ALL_OBJECTS_DIR}/CompileStylesheet.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/CompileStylesheet/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/CompileStylesheet/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+DocumentBuilder: lib $(BINTARGETDIR)/DocumentBuilder
+
+$(BINTARGETDIR)/DocumentBuilder: ${ALL_OBJECTS_DIR}/DocumentBuilder.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/DocumentBuilder/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/DocumentBuilder/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+ExternalFunction: lib $(BINTARGETDIR)/ExternalFunction
+
+$(BINTARGETDIR)/ExternalFunction: ${ALL_OBJECTS_DIR}/ExternalFunction.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/ExternalFunction/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/ExternalFunction/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+SimpleTransform: lib $(BINTARGETDIR)/SimpleTransform
+
+$(BINTARGETDIR)/SimpleTransform: ${ALL_OBJECTS_DIR}/SimpleTransform.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/SimpleTransform/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/SimpleTransform/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+SimpleXPathAPI: lib $(BINTARGETDIR)/SimpleXPathAPI
+
+$(BINTARGETDIR)/SimpleXPathAPI: ${ALL_OBJECTS_DIR}/SimpleXPathAPI.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/SimpleXPathAPI/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/SimpleXPathAPI/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+StreamTransform: lib $(BINTARGETDIR)/StreamTransform
+
+$(BINTARGETDIR)/StreamTransform: ${ALL_OBJECTS_DIR}/StreamTransform.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/StreamTransform/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<		
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/StreamTransform/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<		
+endif
+
+TraceListen: lib $(BINTARGETDIR)/TraceListen
+
+$(BINTARGETDIR)/TraceListen: ${ALL_OBJECTS_DIR}/TraceListen.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/TraceListen/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<		
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/TraceListen/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<		
+endif
+
+UseStylesheetParam: lib $(BINTARGETDIR)/UseStylesheetParam
+
+$(BINTARGETDIR)/UseStylesheetParam: ${ALL_OBJECTS_DIR}/UseStylesheetParam.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/UseStylesheetParam/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<	
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/UseStylesheetParam/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<	
+endif
+
+XalanTransform: lib $(BINTARGETDIR)/XalanTransform
+
+$(BINTARGETDIR)/XalanTransform: ${ALL_OBJECTS_DIR}/XalanTransform.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XalanTransform/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XalanTransform/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+XalanTransformerCallback: lib $(BINTARGETDIR)/XalanTransformerCallback
+
+$(BINTARGETDIR)/XalanTransformerCallback: ${ALL_OBJECTS_DIR}/XalanTransformerCallback.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XalanTransformerCallback/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XalanTransformerCallback/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+XPathWrapper: lib $(BINTARGETDIR)/XPathWrapper
+
+$(BINTARGETDIR)/XPathWrapper: ${ALL_OBJECTS_DIR}/XPathWrapper.o ${ALL_OBJECTS_DIR}/TestDriver.o
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XPathWrapper/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(SAMPLES_DIR)/XPathWrapper/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+Tests: lib  ThreadTest
+
+ThreadTest: lib $(BINTARGETDIR)/ThreadTest
+
+$(BINTARGETDIR)/ThreadTest: ${ALL_OBJECTS_DIR}/ThreadTest.o 
+ifeq ($(PLATFORM), OS390)                                                       
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} $(LIB_DIR)/lib$(PROJECT_NAME)$(VER).x $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(TESTS_DIR)/Threads/%.cpp
+	$(CC3) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+else
+	${LINK} $(XSL_BUILD_OPTIONS) ${PLATFORM_LIB_LINK_OPTIONS} ${LIBRARY_SEARCH_PATHS} \
+	${EXTRA_LINK_OPTIONS} -L$(LIB_DIR) -l$(PROJECT_NAME)$(VER) $(ALLLIBS) $(CXXFLAGS) $^ -o $@	
+${ALL_OBJECTS_DIR}/%.o:$(TESTS_DIR)/Threads/%.cpp
+	$(CC1) $(XSL_BUILD_OPTIONS) -c $(XSL_INCL) $(EXTRA_COMPILE_OPTIONS) -o $@ $<
+endif
+
+lib:	prepare compile $(THISLIB)$(VER)$(SHLIBSUFFIX)
+
+$(THISLIB)$(VER)$(SHLIBSUFFIX): $(ALL_OBJECTS)
+	$(MAKE_SHARED) $(PLATFORM_LIBRARIES) $(EXTRA_LINK_OPTIONS) $(ALLLIBS) $^ -o $@ 
+ifeq ($(PLATFORM), OS390)            
+	cp -p *.x  ${LIB_DIR}        
+endif                                
+
+clean:
+	rm -rf $(ALL_OBJECTS_DIR)/*
+ifeq ($(PLATFORM), TRU64)
+	rm -rf $(ALL_OBJECTS_DIR)/.cxx_repository
+endif
+	rm -f $(THISLIB)$(VER)$(SHLIBSUFFIX)
+	rm -f $(BINTARGETDIR)/testXSLT
+	rm -f $(BINTARGETDIR)/testXPath
+	rm -f ${LIB_DIR}/mod_xslt$(SHLIBSUFFIX) 	
+	rm -f $(BINTARGETDIR)/CompileStylesheet
+	rm -f $(BINTARGETDIR)/ExternalFunction
+	rm -f $(BINTARGETDIR)/SimpleTransform
+	rm -f $(BINTARGETDIR)/StreamTransform
+	rm -f $(BINTARGETDIR)/TraceListen
+	rm -f $(BINTARGETDIR)/UseStylesheetParam
+	rm -f $(BINTARGETDIR)/XalanTransform
+	rm -f $(BINTARGETDIR)/XPathWrapper
+
diff --git a/src/TestXSLT/process.cpp b/src/TestXSLT/process.cpp
new file mode 100644
index 0000000..46dde32
--- /dev/null
+++ b/src/TestXSLT/process.cpp
@@ -0,0 +1,1370 @@
+/*
+ * 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/>.
+ */
+
+#include <Include/PlatformDefinitions.hpp>
+
+
+
+#include <cstdio>
+#include <cstring>
+
+
+
+#if defined(XALAN_OLD_STREAM_HEADERS)
+#include <iostream.h>
+#else
+#include <iostream>
+#endif
+
+
+
+#if !defined(NDEBUG) && defined(_MSC_VER)
+#include <crtdbg.h>
+#endif
+
+
+
+#include <util/PlatformUtils.hpp>
+#include <sax/SAXException.hpp>
+
+
+
+#include <XalanDOM/XalanDOMException.hpp>
+
+
+
+#include <PlatformSupport/DOMStringHelper.hpp>
+#include <PlatformSupport/DOMStringPrintWriter.hpp>
+#include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
+#include <PlatformSupport/XalanFileOutputStream.hpp>
+#include <PlatformSupport/XalanStdOutputStream.hpp>
+
+
+
+#include <Include/XalanAutoPtr.hpp>
+
+
+
+#include <DOMSupport/DOMSupportDefault.hpp>
+
+
+
+#include <XPath/XObjectFactoryDefault.hpp>
+#include <XPath/XPathEnvSupportDefault.hpp>
+#include <XPath/XPath.hpp>
+#include <XPath/XPathExecutionContextDefault.hpp>
+#include <XPath/XPathFactoryBlock.hpp>
+#include <XPath/XPathFactoryDefault.hpp>
+#include <XPath/XPathProcessorImpl.hpp>
+
+
+
+#include <XalanExtensions/XalanExtensions.hpp>
+
+
+
+#include <XercesParserLiaison/XercesParserLiaison.hpp>
+#include <XercesParserLiaison/XercesDOMSupport.hpp>
+
+
+
+#include <XMLSupport/FormatterToDOM.hpp>
+#include <XMLSupport/FormatterToHTML.hpp>
+#include <XMLSupport/FormatterToNull.hpp>
+#include <XMLSupport/FormatterToText.hpp>
+#include <XMLSupport/FormatterToXML.hpp>
+#include <XMLSupport/FormatterTreeWalker.hpp>
+
+
+
+#include <XalanSourceTree/FormatterToSourceTree.hpp>
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+#include <XalanSourceTree/XalanSourceTreeDocument.hpp>
+#include <XalanSourceTree/XalanSourceTreeInit.hpp>
+#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
+
+
+
+#include <XSLT/XSLTEngineImpl.hpp>
+#include <XSLT/XSLTInit.hpp>
+#include <XSLT/XSLTInputSource.hpp>
+#include <XSLT/XSLTResultTarget.hpp>
+#include <XSLT/StylesheetRoot.hpp>
+#include <XSLT/StylesheetConstructionContextDefault.hpp>
+#include <XSLT/StylesheetExecutionContextDefault.hpp>
+#include <XSLT/TraceListenerDefault.hpp>
+#include <XSLT/XSLTProcessorEnvSupportDefault.hpp>
+
+
+
+//#define XALAN_USE_ICU
+#if defined(XALAN_USE_ICU)
+#include <ICUBridge/ICUBridge.hpp>
+#include <ICUBridge/FunctionICUFormatNumber.hpp>
+#include <ICUBridge/ICUBridgeCollationCompareFunctor.hpp>
+#endif
+
+
+
+//#define XALAN_VQ_SPECIAL_TRACE
+#if defined(XALAN_VQ_SPECIAL_TRACE)
+#include "C:/Program Files/Rational/Quantify/pure.h"
+#endif
+
+
+
+#if !defined (XALAN_NO_NAMESPACES)
+using std::cerr;
+using std::cin;
+using std::cout;
+using std::endl;
+using std::hex;
+using std::pair;
+using std::vector;
+#endif
+
+
+
+/**
+ * Print argument options.
+ */ 
+void
+printArgOptions()
+{
+	cerr << endl
+		 << "TestXSLT options: "
+		 << endl
+		 << endl
+		 << "Options are not case-sensitive."
+		 << endl
+		 << endl
+		 << " [-? Shows this message.]"
+		 << endl
+		 << endl
+		 << " [-h Shows this message.]"
+		 << endl
+		 << endl
+		 << " [-IN inputXMLURL (If not specified, stdin is used.)]"
+		 << endl
+		 << endl
+		 << " [-XSL XSLTransformationURL]"
+		 << endl
+		 << " [-OUT outputFileName]"
+		 << endl
+		 << " [-V (Show version information only.)]"
+		 << endl
+		 << " [-QC (Quiet pattern conflicts warnings.)]"
+		 << endl
+		 << " [-Q (Use quiet mode.)]"
+		 << endl
+		 << " [-INDENT n (Controls how many spaces to indent. {default is 0})]"
+		 << endl
+		 << " [-VALIDATE (Controls whether validation occurs. Validation is off by default.)]"
+		 << endl
+		 << endl
+		 << " [-TT (Trace the templates as they are being called.)]"
+		 << endl
+		 << " [-TG (Trace each generation event.)]"
+		 << endl
+		 << " [-TS (Trace each selection event.)]"
+		 << endl
+		 << " [-TTC (Trace the template children as they are being processed.)]"
+		 << endl
+		 << endl
+		 << " [-XML (Use XML formatter and add XML header.)]"
+		 << endl
+		 << " [-TEXT (Use Text formatter.)]"
+		 << endl
+		 << " [-HTML (Use HTML formatter.)]"
+		 << endl
+		 << " [-DOM (Use DOM formatter.  Formats to DOM, then formats XML for output.)]"
+		 << endl
+		 << " [-XST (Use source tree formatter.  Formats to Xalan source tree, then formats XML for output.)]"
+		 << endl
+		 << endl
+		 << " [-PARAM name expression (Sets a stylesheet parameter.)]"
+		 << endl
+		 << endl
+		 << " [-XD (Use Xerces DOM instead of Xalan source tree.)]"
+		 << endl
+		 << endl
+		 << " [-DE (Disable built-in extension functions.)]"
+		 << endl
+		 << " [-EN (Specify the namespace URI for Xalan extension functions.  The default is 'http://xml.apache.org/xalan')]"
+		 << endl
+		 << endl
+		 << "The following options are valid only with -HTML or -XML."
+		 << endl
+		 << endl
+		 << " [-STRIPCDATA (Strip CDATA sections of their brackets, but don't escape.)"
+		 << endl
+		 << " [-ESCAPECDATA (Strip CDATA sections of their brackets, but escape.)"
+		 << endl
+		 << endl
+		 << "The following option is valid only with -HTML."
+		 << endl
+		 << endl
+		 << " [-NOINDENT (Turns off HTML indenting..]"
+		 << endl
+		 << endl
+		 << "The following option is valid only with -XML."
+		 << endl
+		 << endl
+		 << " [-NH (Don't write XML header.)]"
+		 << endl;
+}
+
+
+
+typedef vector<pair<const char*, const char*> >	StringPairVectorType;
+
+
+
+struct CmdLineParams
+{
+	StringPairVectorType params;
+
+	bool		escapeCData;
+	bool		setQuietConflictWarnings;
+	bool		setQuietMode;
+	bool		stripCData;
+	bool		versionOnly;
+	bool		traceTemplates;
+	bool		traceGenerationEvent;
+	bool		traceSelectionEvent;
+	bool		traceTemplateChildren;
+	bool		shouldWriteXMLHeader;
+	bool		doValidation;
+	bool		noIndent;
+	bool		formatToNull;
+	bool		formatToSourceTree;
+	bool		useDOM;
+	bool		disableExtensions;
+
+	int			indentAmount;
+	int			outputType;
+
+	const char*		outFileName;
+	const char*		xslFileName;
+	const char*		inFileName;
+	const char*		extentionsNamespace;
+
+	CmdLineParams() :
+		params(),
+		escapeCData(false),
+		setQuietConflictWarnings(false),
+		setQuietMode(false),
+		stripCData(false),
+		versionOnly(false),
+		traceTemplates(false),
+		traceGenerationEvent(false),
+		traceSelectionEvent(false),
+		traceTemplateChildren(false),
+		shouldWriteXMLHeader(true),
+		doValidation(false),
+		noIndent(false),
+		formatToNull(false),
+		formatToSourceTree(false),
+		useDOM(false),
+		disableExtensions(false),
+		indentAmount(-1),
+		outputType(-1),
+		outFileName(0),
+		xslFileName(0),
+		inFileName(0),
+		extentionsNamespace(0)
+	{
+	}
+};
+
+
+
+void
+warnPreviousOutputMethod(int	outputMethod)
+{
+	cerr << endl << "Warning: Ignoring previous output method switch ";
+
+	switch(outputMethod)
+	{
+	case FormatterListener::OUTPUT_METHOD_XML:
+		cerr << "-XML.";
+		break;
+
+	case FormatterListener::OUTPUT_METHOD_TEXT:
+		cerr << "-TEXT.";
+		break;
+
+	case FormatterListener::OUTPUT_METHOD_HTML:
+		cerr << "-HTML.";
+		break;
+
+	case FormatterListener::OUTPUT_METHOD_DOM:
+		cerr << "-DOM.";
+		break;		
+	}
+
+	cerr << endl << endl;
+}
+
+
+
+#if defined(OS390)
+#include <strings.h>                                             
+                                                                  
+int
+compareNoCase(
+			const char*		str1,
+			const char*		str2)     
+{
+	return strcasecmp(str1, str2);
+}
+
+#else
+
+int
+compareNoCase(
+			const char*		str1,
+			const char*		str2)     
+{
+	return stricmp(str1, str2);
+}
+
+#endif
+
+
+
+bool
+getArgs(
+			int				argc,
+			const char*		argv[],
+			CmdLineParams&	p)
+{
+	bool fSuccess = true;
+
+	for (int i = 1; i < argc && fSuccess == true; ++i)
+	{
+		if (!compareNoCase("-h", argv[i]) || !compareNoCase("-?", argv[i]))
+		{
+			fSuccess = false;
+		}
+		else if (!compareNoCase("-IN", argv[i]))
+		{
+			++i;
+
+			if(i < argc && argv[i][0] != '-')
+			{
+				p.inFileName = argv[i];
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else if (!compareNoCase("-XSL", argv[i]))
+		{
+			++i;
+
+			if(i < argc && argv[i][0] != '-')
+			{
+				p.xslFileName = argv[i];
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else if (!compareNoCase("-OUT", argv[i]))
+		{
+			++i;
+
+			if(i < argc && argv[i][0] != '-')
+			{
+				p.outFileName = argv[i];
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else if (!compareNoCase("-NOINDENT", argv[i]))
+		{
+			p.noIndent = true;
+		} 
+		else if (!compareNoCase("-INDENT", argv[i]))
+		{
+			++i;
+
+			if(i < argc && argv[i][0] != '-')
+			{
+				p.indentAmount = atoi(argv[i]);
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else if(!compareNoCase("-VALIDATE", argv[i]))
+		{
+			p.doValidation = true;
+		}
+		else if (!compareNoCase("-PARAM", argv[i])) 
+		{
+			++i;
+
+			if(i < argc && argv[i][0] != '-')
+			{
+				const char* const	name = argv[i];
+
+				++i;
+
+				// Don't check for '-' here, since that might
+				// be a valid character in a parameter value.
+				if(i < argc)
+				{
+					typedef StringPairVectorType::value_type	value_type;
+
+					p.params.push_back(value_type(name, argv[i]));
+				}
+				else
+				{
+					fSuccess = false;
+				}
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else if(!compareNoCase("-V", argv[i]))
+		{
+			p.versionOnly = true;
+		}
+		else if(!compareNoCase("-QC", argv[i]))
+		{
+			p.setQuietConflictWarnings = true;
+		}
+		else if(!compareNoCase("-Q", argv[i]))
+		{
+			p.setQuietMode = true;
+		}
+		else if(!compareNoCase("-XML", argv[i]))
+		{
+			if (p.outputType != -1)
+			{
+				warnPreviousOutputMethod(p.outputType);
+			}
+
+			p.outputType = FormatterListener::OUTPUT_METHOD_XML;
+		}
+		else if(!compareNoCase("-TEXT", argv[i]))
+		{
+			if (p.outputType != -1)
+			{
+				warnPreviousOutputMethod(p.outputType);
+			}
+
+			p.outputType = FormatterListener::OUTPUT_METHOD_TEXT;
+		}
+		else if(!compareNoCase("-HTML", argv[i]))
+		{
+			if (p.outputType != -1)
+			{
+				warnPreviousOutputMethod(p.outputType);
+			}
+
+			p.outputType = FormatterListener::OUTPUT_METHOD_HTML;
+		}
+		else if(!compareNoCase("-DOM", argv[i]))
+		{
+			if (p.outputType != -1)
+			{
+				warnPreviousOutputMethod(p.outputType);
+			}
+
+			p.outputType = FormatterListener::OUTPUT_METHOD_DOM;
+		}
+		else if(!compareNoCase("-XST", argv[i]))
+		{
+			if (p.outputType != -1)
+			{
+				warnPreviousOutputMethod(p.outputType);
+			}
+
+			p.outputType = FormatterListener::OUTPUT_METHOD_DOM;
+
+			p.formatToSourceTree = true;
+		}
+		else if(!compareNoCase("-NULL", argv[i]))
+		{
+			p.formatToNull = true;
+		}
+		else if(!compareNoCase("-STRIPCDATA", argv[i]))
+		{
+			p.stripCData = true;
+		}
+		else if(!compareNoCase("-ESCAPECDATA", argv[i]))
+		{
+			p.escapeCData = true;
+		}
+		else if (!compareNoCase("-NH", argv[i]))
+		{
+			p.shouldWriteXMLHeader = false;
+		}
+		else if(!compareNoCase("-TT", argv[i]))
+		{
+			p.traceTemplates = true;
+		}
+		else if(!compareNoCase("-TG", argv[i]))
+		{
+			p.traceGenerationEvent = true;
+		}
+		else if(!compareNoCase("-TS", argv[i]))
+		{
+			p.traceSelectionEvent = true;
+		}
+		else if(!compareNoCase("-TTC", argv[i]))
+		{
+			p.traceTemplateChildren = true;
+		}
+		else if (!compareNoCase("-XD", argv[i]))
+		{
+			p.useDOM = true;
+		}
+		else if (!compareNoCase("-DE", argv[i]))
+		{
+			p.disableExtensions = true;
+		}
+		else if (!compareNoCase("-EN", argv[i]))
+		{
+			++i;
+
+			if(i < argc)
+			{
+				p.extentionsNamespace = argv[i];
+
+				if (strlen(p.extentionsNamespace) == 0)
+				{
+					fSuccess = false;
+				}
+			}
+			else
+			{
+				fSuccess = false;
+			}
+		}
+		else
+		{
+			cerr << endl << "Warning: Ignoring unknown option \"" << argv[i] << "\"." << endl << endl;
+		}
+	}
+
+	return fSuccess;
+}
+
+
+
+FormatterListener*
+createFormatter(
+			int								outputType,
+			bool							shouldWriteXMLHeader,
+			bool							stripCData,
+			bool							escapeCData,
+			bool							noIndent,
+			bool							formatToNull,
+			bool							formatToSourceTree,
+			PrintWriter&					resultWriter,
+			int								indentAmount,
+			const XalanDOMString&			mimeEncoding,
+			const StylesheetRoot*			stylesheet,
+			XMLParserLiaison&				parserLiaison,
+			XalanSourceTreeParserLiaison&	sourceTreeParserLiaison,
+			const PrefixResolver&			prefixResolver,
+			const XalanDocument*&			theResultDocument)
+{
+	FormatterListener*	formatter = 0;
+
+	if (formatToNull == true)
+	{
+		formatter = new FormatterToNull;
+	}
+	else if(FormatterListener::OUTPUT_METHOD_XML == outputType)
+	{
+		XalanDOMString	version;
+		bool			outputIndent = false;
+		XalanDOMString	mediatype;
+		XalanDOMString	doctypeSystem;
+		XalanDOMString	doctypePublic;
+		XalanDOMString	standalone;
+
+		if (stylesheet != 0)
+		{
+			version = stylesheet->m_version;
+
+			mediatype = stylesheet->m_mediatype;
+			doctypeSystem = stylesheet->getOutputDoctypeSystem();
+			doctypePublic = stylesheet->getOutputDoctypePublic();
+			standalone = stylesheet->m_standalone;
+		}
+
+		FormatterToXML* const	fToXML =
+			new FormatterToXML(
+					resultWriter,
+					version,
+					outputIndent,
+					indentAmount,
+					mimeEncoding,
+					mediatype,
+					doctypeSystem,
+					doctypePublic,
+					true,	// xmlDecl
+					standalone);
+
+		fToXML->setShouldWriteXMLHeader(shouldWriteXMLHeader);
+		fToXML->setStripCData(stripCData);
+		fToXML->setEscapeCData(escapeCData);
+
+		formatter = fToXML;
+	}
+	else if(FormatterListener::OUTPUT_METHOD_TEXT == outputType)
+	{
+		formatter = new FormatterToText(resultWriter, mimeEncoding);
+	}
+	else if(FormatterListener::OUTPUT_METHOD_HTML == outputType)
+	{
+		XalanDOMString	version;
+		bool			outputIndent = !noIndent;
+		XalanDOMString	mediatype;
+		XalanDOMString	doctypeSystem;
+		XalanDOMString	doctypePublic;
+		XalanDOMString	standalone;
+
+		if (stylesheet != 0)
+		{
+			version = stylesheet->m_version;
+
+			if (noIndent == false)
+			{
+				outputIndent = stylesheet->getOutputIndent();
+			}
+
+			mediatype = stylesheet->m_mediatype;
+			doctypeSystem = stylesheet->getOutputDoctypeSystem();
+			doctypePublic = stylesheet->getOutputDoctypePublic();
+			standalone = stylesheet->m_standalone;
+		}
+
+		FormatterToHTML* const	fToHTML =
+				new FormatterToHTML(
+						resultWriter,
+						mimeEncoding,
+						mediatype,
+						doctypeSystem,
+						doctypePublic,
+						outputIndent,
+						indentAmount,
+						version,
+						standalone,
+						false);	// xmlDecl
+
+		fToHTML->setStripCData(stripCData);
+		fToHTML->setPrefixResolver(&prefixResolver);
+
+		formatter = fToHTML;
+	}
+	else if(FormatterListener::OUTPUT_METHOD_DOM == outputType)
+	{
+		if (formatToSourceTree == true)
+		{
+			XalanSourceTreeDocument*	theDocument =
+				sourceTreeParserLiaison.createXalanSourceTreeDocument();
+			assert(theDocument != 0);
+
+			theResultDocument = theDocument;
+
+			FormatterToSourceTree* const	fToSourceTree =
+				new FormatterToSourceTree(theDocument);
+
+			fToSourceTree->setPrefixResolver(&prefixResolver);
+
+			formatter = fToSourceTree;
+		}
+		else
+		{
+			XalanDocument* const	theDocument =
+				parserLiaison.createDOMFactory();
+			assert(theDocument != 0);
+
+			theResultDocument = theDocument;
+
+			FormatterToDOM* const	fToDOM =
+				new FormatterToDOM(theDocument, 0);
+
+			fToDOM->setPrefixResolver(&prefixResolver);
+
+			formatter = fToDOM;
+		}
+	}
+
+	return formatter;
+}
+
+
+
+XalanOutputStream*
+createOutputStream(const CmdLineParams&		params)
+{
+	if (params.outFileName == 0)
+	{
+		return new XalanStdOutputStream(cout);
+	}
+	else
+	{
+		return new XalanFileOutputStream(TranscodeFromLocalCodePage(params.outFileName));
+	}
+}
+
+
+
+TraceListener*
+createTraceListener(
+			const CmdLineParams&	params,
+			PrintWriter&			diagnosticsWriter)
+{
+	if (params.traceTemplates == true ||
+		params.traceTemplateChildren == true ||
+		params.traceGenerationEvent == true ||
+		params.traceSelectionEvent == true)
+	{
+		return new TraceListenerDefault(
+				diagnosticsWriter,
+				params.traceTemplates,
+				params.traceTemplateChildren,
+				params.traceGenerationEvent,
+				params.traceSelectionEvent);
+	}
+	else
+	{
+		return 0;
+	}
+
+}
+
+
+
+DOMSupport&
+getDOMSupport(
+		XalanSourceTreeDOMSupport&	theXalanSourceTreeDOMSupport,
+		XercesDOMSupport&			theXercesDOMSupport,
+		const CmdLineParams&		params)
+{
+	if (params.useDOM == false)
+	{
+		return theXalanSourceTreeDOMSupport;
+	}
+	else
+	{
+		return theXercesDOMSupport;
+	}
+}
+
+
+
+XMLParserLiaison&
+getParserLiaison(
+		XalanSourceTreeParserLiaison&	theXalanSourceTreeParserLiaison,
+		XercesParserLiaison&			theXercesParserLiaison,
+		const CmdLineParams&			params)
+{
+	if (params.useDOM == false)
+	{
+		return theXalanSourceTreeParserLiaison;
+	}
+	else
+	{
+		return theXercesParserLiaison;
+	}
+}
+
+
+
+void
+installExtensions(
+			const CmdLineParams&				params,
+			XSLTProcessorEnvSupportDefault&		theXSLProcessorSupport)
+{
+	XalanDOMString	theXalanNamespace;
+
+	if (params.extentionsNamespace != 0)
+	{
+		theXalanNamespace = XalanDOMString(params.extentionsNamespace);
+		assert(length(theXalanNamespace) > 0);
+	}
+	else
+	{
+		theXalanNamespace = XALAN_STATIC_UCODE_STRING("http://xml.apache.org/xalan");
+	}
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("difference")),
+			FunctionDifference());
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("distinct")),
+			FunctionDistinct());
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("evaluate")),
+			FunctionEvaluate());
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("hasSameNodes")),
+			FunctionHasSameNodes());
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("intersection")),
+			FunctionIntersection());
+
+	theXSLProcessorSupport.installExternalFunctionLocal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("nodeset")),
+			FunctionNodeSet());
+}
+
+
+
+int
+xsltMain(const CmdLineParams&	params)
+{
+	// Initialize the XSLT subsystem.  This must stay in scope until
+	// we're done with the subsystem, since its destructor shuts down
+	// the subsystem.
+	XSLTInit	theInit;
+
+#if defined(XALAN_USE_ICU)
+	// Create an installer to install the substitute format-number() function.
+	FunctionICUFormatNumber::FunctionICUFormatNumberInstaller	theInstaller;
+#endif
+
+	const XalanDOMString	mimeEncoding(XALAN_STATIC_UCODE_STRING("UTF-8"));
+	const XalanDOMString	encoding(XALAN_STATIC_UCODE_STRING("UTF-8"));
+
+	/**
+	 * The default diagnostic writer...
+	 */
+	XalanStdOutputStream				theStdErr(cerr);
+	XalanOutputStreamPrintWriter		diagnosticsWriter(theStdErr);
+
+	// Make sure that error reporting, which includes any TraceListener output
+	// does not throw exceptions when transcoding, since that could result in
+	// an exception being thrown will another exception is active.  In particular,
+	// characters that the TraceListener writes might not be representable in the
+	// local code page.
+	theStdErr.setThrowTranscodeException(false);
+
+	// Initialize the XalanSourceTree subsystem.  This must stay in scope until
+	// we're done with the subsystem, since its destructor shuts down the
+	// subsystem.
+	XalanSourceTreeInit				theXalanSourceTreeInit;
+
+	XalanSourceTreeDOMSupport		theXalanSourceTreeDOMSupport;
+	XalanSourceTreeParserLiaison	theXalanSourceTreeParserLiaison(theXalanSourceTreeDOMSupport);
+
+	// Hookup the parser liaison instance to the support instance.
+	theXalanSourceTreeDOMSupport.setParserLiaison(&theXalanSourceTreeParserLiaison);
+
+
+	XercesDOMSupport		theXercesDOMSupport;
+	XercesParserLiaison		theXercesParserLiaison(theXercesDOMSupport);
+
+	DOMSupport&				theDOMSupport = getDOMSupport(
+		theXalanSourceTreeDOMSupport,
+		theXercesDOMSupport,
+		params);
+
+	XMLParserLiaison&		xmlParserLiaison = getParserLiaison(
+		theXalanSourceTreeParserLiaison,
+		theXercesParserLiaison,
+		params);
+
+	XSLTProcessorEnvSupportDefault	theXSLProcessorSupport;
+
+	if (params.disableExtensions == false)
+	{
+		installExtensions(params, theXSLProcessorSupport);
+	}
+
+	XObjectFactoryDefault	theXObjectFactory;
+
+	XPathFactoryDefault		theXPathFactory;
+
+	const XalanAutoPtr<TraceListener>		theTraceListener(
+			createTraceListener(
+				params,
+				diagnosticsWriter));
+
+	XSLTEngineImpl	processor(
+			xmlParserLiaison,
+			theXSLProcessorSupport,
+			theDOMSupport,
+			theXObjectFactory,
+			theXPathFactory);
+
+	theXSLProcessorSupport.setProcessor(&processor);
+
+	if (theTraceListener.get() != 0)
+	{
+		processor.setTraceSelects(params.traceSelectionEvent);
+		processor.addTraceListener(theTraceListener.get());
+	}
+
+	// Use a different factory type for the stylesheet.  This is an optimization, since
+	// stylesheet XPath instances are built all at once and are deleted all at once when
+	// the stylesheet is destroyed.
+	XPathFactoryBlock	theStylesheetXPathFactory;
+
+	StylesheetConstructionContextDefault	theConstructionContext(
+			processor,
+			theStylesheetXPathFactory);
+
+	/*
+	 * Set specified processor flags
+	 */
+	processor.setQuietConflictWarnings(params.setQuietConflictWarnings);
+
+	if (params.params.size() > 0)
+	{
+		StringPairVectorType::const_iterator	it = params.params.begin();
+
+		for ( ; it != params.params.end(); ++it)
+		{
+			assert((*it).first != 0 && (*it).second != 0);
+
+			processor.setStylesheetParam(
+					XalanDOMString((*it).first),
+					XalanDOMString((*it).second));
+		}
+	}
+
+	/*
+	 * Set specified parser flags
+	 */
+	if (params.indentAmount != 0)
+	{
+		xmlParserLiaison.setIndent(params.indentAmount);
+	}
+
+	xmlParserLiaison.setUseValidation(params.doValidation);
+
+	if (!params.setQuietMode)
+	{
+		processor.setDiagnosticsOutput(&diagnosticsWriter);
+	}
+
+	XalanDOMString	xslFileName;
+
+	if(params.xslFileName != 0)
+	{
+		xslFileName = params.xslFileName;
+	}
+
+	const StylesheetRoot*	stylesheet = 0;
+
+	if (!isEmpty(xslFileName))
+	{
+		stylesheet = processor.processStylesheet(xslFileName, theConstructionContext);
+	}
+
+	XalanAutoPtr<XalanOutputStream>		outputFileStream(createOutputStream(params));
+	assert(outputFileStream.get() != 0);
+
+	XalanOutputStreamPrintWriter	resultWriter(*outputFileStream.get());
+
+	const XalanDocument*	theResultDocument = 0;
+
+	const XalanAutoPtr<FormatterListener>	formatter(
+			createFormatter(
+				params.outputType,
+				params.shouldWriteXMLHeader,
+				params.stripCData,
+				params.escapeCData,
+				params.noIndent,
+				params.formatToNull,
+				params.formatToSourceTree,
+				resultWriter,
+				xmlParserLiaison.getIndent(),
+				mimeEncoding,
+				stylesheet,
+				xmlParserLiaison,
+				theXalanSourceTreeParserLiaison,
+				processor,
+				theResultDocument));
+
+	XSLTResultTarget	rTreeTarget;
+
+	if(formatter.get() == 0)
+	{
+		rTreeTarget.setCharacterStream(&resultWriter);
+	}
+	else
+	{
+		rTreeTarget.setFormatterListener(formatter.get());
+	}
+
+	// Do the transformation...
+	XSLTInputSource		theInputSource;
+
+	if (params.inFileName != 0)
+	{
+		theInputSource.setSystemId(c_wstr(XalanDOMString(params.inFileName)));
+	}
+	else
+	{
+		theInputSource.setStream(&cin);
+
+		cerr << "Reading input document from stdin..." << endl;
+	}
+
+	StylesheetExecutionContextDefault	theExecutionContext(processor,
+			theXSLProcessorSupport,
+			theDOMSupport,
+			theXObjectFactory);
+
+#if defined(XALAN_USE_ICU)
+	ICUBridgeCollationCompareFunctor	theICUFunctor;
+
+	theExecutionContext.installCollationCompareFunctor(&theICUFunctor);
+#endif
+
+	if (params.useDOM == false)
+	{
+		theXalanSourceTreeParserLiaison.setExecutionContext(theExecutionContext);
+	}
+	else
+	{
+		theXercesParserLiaison.setExecutionContext(theExecutionContext);
+	}
+
+	if (stylesheet == 0)
+	{
+		// No stylesheet, so our only hope is that the xml file has
+		// PI with the stylesheet...
+
+		// Dummy input source...
+		XSLTInputSource		theStylesheetSource;
+
+		processor.process(
+				theInputSource,
+				theStylesheetSource,
+				rTreeTarget,
+				theConstructionContext,
+				theExecutionContext);
+	}
+	else
+	{
+		theExecutionContext.setStylesheetRoot(stylesheet);
+
+		processor.process(
+				theInputSource,
+				rTreeTarget,
+				theExecutionContext);
+	}
+
+	if (params.outputType == FormatterListener::OUTPUT_METHOD_DOM)
+	{
+		// Output is to DOM, so we have to format to XML to
+		// produce output...
+		assert(rTreeTarget.getFormatterListener() != 0 &&
+			   rTreeTarget.getFormatterListener()->getOutputFormat() ==
+					FormatterListener::OUTPUT_METHOD_DOM);
+
+		if (theResultDocument == 0)
+		{
+			cerr << endl << "Error: No document to format!!!" << endl;
+		}
+		else
+		{
+			// Create a FormaterToXML with the required output
+			// options...
+			const XalanAutoPtr<FormatterListener>	formatter(
+					createFormatter(
+						FormatterListener::OUTPUT_METHOD_XML,
+						params.shouldWriteXMLHeader,
+						params.stripCData,
+						params.escapeCData,
+						params.noIndent,
+						false,
+						false,
+						resultWriter,
+						xmlParserLiaison.getIndent(),
+						mimeEncoding,
+						stylesheet,
+						xmlParserLiaison,
+						theXalanSourceTreeParserLiaison,
+						processor,
+						theResultDocument));
+
+			// Create a FormatterTreeWalker with the the
+			// new formatter...
+			FormatterTreeWalker theTreeWalker(*formatter.get());
+
+			// Walk the document and produce the XML...
+			theTreeWalker.traverse(theResultDocument);
+		}
+	}
+
+	theExecutionContext.reset();
+
+	theConstructionContext.reset();
+	theStylesheetXPathFactory.reset();
+
+	processor.reset();
+
+	theXPathFactory.reset();
+	theXObjectFactory.reset();
+	theXSLProcessorSupport.reset();
+	theDOMSupport.reset();
+
+	xmlParserLiaison.reset();
+
+	return 0;
+}
+
+
+
+int
+main(
+			int				argc,
+			const char*		argv[])
+{
+#if !defined(XALAN_USE_ICU) && !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
+
+#if defined(XALAN_VQ_SPECIAL_TRACE)
+	QuantifyStopRecordingData();
+#endif
+
+	int				theResult = 0;
+
+	CmdLineParams	theParams;
+
+	/*
+	 *		Get command line arguments
+	 */
+	if (getArgs(argc, argv, theParams) == false)
+	{
+		printArgOptions();
+	}
+	else if (theParams.versionOnly == true)
+	{
+		cout << endl
+			 << "TestXSLT version 1.2.0 (Xalan C++ version 1.2.0)"
+			 << endl;
+	}
+	else
+	{
+		XMLPlatformUtils::Initialize();
+
+		try
+		{
+			theResult = xsltMain(theParams);
+		}
+		catch (XSLException& e)
+		{
+			cout << "\nXSLException ";
+
+			cout << "Type is: " << e.getType() << endl;
+
+			cout << "Message is: " << e.getMessage() << " (";
+
+			const XalanDOMString&	theURI = e.getURI();
+
+			if (length(theURI) != 0)
+			{
+				cout << theURI;
+			}
+			else
+			{
+				cout << "Unknown URI";
+			}
+
+			const int	theLineNumber = e.getLineNumber();
+
+			if (theLineNumber != -1)
+			{
+				cout << ", line " << theLineNumber;
+			}
+			else
+			{
+				cout << ", unknown line";
+			}
+
+			const int	theColumnNumber = e.getColumnNumber();
+
+			if (theColumnNumber != -1)
+			{
+				cout << ", column " << theColumnNumber;
+			}
+			else
+			{
+				cout << ", unknown column";
+			}
+
+			cout << ")" << endl;
+
+			theResult = -1;
+		}
+		catch (SAXException& e)
+		{
+			cout << "\nSAXException ";
+
+			cout << "Message is: " << e.getMessage() << endl;
+
+			theResult = -2;
+		}
+		catch (XMLException& e)
+		{
+			cout << "\nXMLException ";
+
+			cout << "Type is: " << e.getType() << endl;
+
+			cout << "Message is: " << e.getMessage() << endl;
+
+			theResult = -3;
+		}
+		catch(const XalanDOMException&	e)
+		{
+			cout << endl
+				 << "XalanDOMException caught.  The code is "
+				 << int(e.getExceptionCode())
+				 << "."
+				 << endl;
+
+			theResult = -4;
+		}
+		catch (...)
+		{
+			cout << "\nUnhandled Exception\n";
+
+			theResult = -5;
+		}
+
+#if !defined(NDEBUG)
+		const size_t	theInstanceCount =
+				XalanNode::getInstanceCount();
+
+		if (theInstanceCount > 0)
+		{
+			cout << "There are "
+				 << XalanNode::getInstanceCount()
+				 << " XalanNode instances still alive!"
+				 << endl
+				 << endl
+				 << "A dump of these instances follows..."
+				 << endl
+				 << endl;
+
+			typedef vector<XalanNode*>	NodeVectorType;
+
+			NodeVectorType	theNodes(theInstanceCount, NodeVectorType::value_type(0));
+
+			XalanNode::getLiveInstances(&*theNodes.begin());
+
+			for(unsigned int i = 0; i < theInstanceCount; ++i)
+			{
+				const XalanNode* const	theInstance = theNodes[i];
+
+				if(theInstance == 0)
+				{
+					cout << "No instance information is available..."
+						 << endl;
+				}
+				else
+				{
+					cout << "("
+						 << hex
+						 << theInstance
+						 << ")  Node name: \""
+						 << theInstance->getNodeName()
+						 << "\"  Node value: \""
+						 << theInstance->getNodeValue()
+						 << "\""
+#if defined(XALAN_RTTI_AVAILABLE) && !defined(XALAN_NO_TYPEINFO)
+						 << "  Type: \""
+						 << typeid(*theInstance).name()
+						 << "\""
+#endif
+						 << endl
+						 << endl;
+				}
+			}
+		}
+#endif
+
+		XMLPlatformUtils::Terminate();
+	}
+
+	return theResult;
+}
diff --git a/src/XSLT/Stylesheet.cpp b/src/XSLT/Stylesheet.cpp
new file mode 100644
index 0000000..a6084ca
--- /dev/null
+++ b/src/XSLT/Stylesheet.cpp
@@ -0,0 +1,1866 @@
+/*
+ * 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/>.
+ *
+ * $ Id: $
+ *
+ */
+
+#include "Stylesheet.hpp"
+
+
+
+#include <algorithm>
+
+
+
+#include <sax/AttributeList.hpp>
+
+
+
+#include <Include/STLHelper.hpp>
+
+
+
+#include <XalanDOM/XalanDOMException.hpp>
+
+
+
+#include <DOMSupport/DOMServices.hpp>
+
+
+
+#include <XMLSupport/XMLParserLiaison.hpp>
+
+
+
+#include <XPath/ElementPrefixResolverProxy.hpp>
+#include <XPath/XObject.hpp>
+#include <XPath/XPath.hpp>
+#include <XPath/XalanQNameByReference.hpp>
+
+
+
+#include "Constants.hpp"
+#include "ElemAttributeSet.hpp"
+#include "ElemDecimalFormat.hpp"
+#include "ElemTemplate.hpp"
+#include "ElemTemplateElement.hpp"
+#include "ElemVariable.hpp"
+#include "ExtensionNSHandler.hpp"
+#include "KeyTable.hpp"
+#include "StylesheetConstructionContext.hpp"
+#include "StylesheetExecutionContext.hpp"
+#include "StylesheetRoot.hpp"
+
+
+
+const Stylesheet::NamespaceVectorType	Stylesheet::s_emptyNamespace;
+
+
+
+const XalanDOMString			Stylesheet::s_emptyString;
+
+const XalanQNameByReference		Stylesheet::s_emptyQName;
+
+const XalanEmptyNamedNodeMap	Stylesheet::s_fakeAttributes;
+
+
+
+Stylesheet::Stylesheet(
+		StylesheetRoot& 				root,
+		const XalanDOMString&			baseIdentifier,
+		StylesheetConstructionContext&	constructionContext) :
+	XalanDocument(),
+	PrefixResolver(),
+	m_stylesheetRoot(root),
+	m_baseIdent(baseIdentifier),
+	m_keyDeclarations(),
+	m_XSLTNamespaceURI(constructionContext.getXSLTNamespaceURI()),
+	m_whitespacePreservingElements(),
+	m_whitespaceStrippingElements(),	
+	m_imports(),
+	m_importsSize(0),
+	m_namespaces(),
+	m_namespaceDecls(),
+	m_isWrapperless(false),
+	m_wrapperlessTemplate(0),
+	m_extensionNamespaces(),
+	m_firstTemplate(0),
+	m_includeStack(),
+	m_namedTemplates(),
+	m_topLevelVariables(),
+	m_XSLTVerDeclared(1.0L),
+	m_isRoot(&root == this ? true: false),
+	m_patternTable(),
+	m_patternTableEnd(m_patternTable.end()),
+	m_textPatternList(),
+	m_commentPatternList(),
+	m_rootPatternList(),
+	m_piPatternList(),
+	m_nodePatternList(),
+	m_anyPatternList(),
+	m_matchPattern2Container(),
+	m_patternCount(0),
+	m_attributeSets(),
+	m_attributeSetsSize(0),
+	m_surrogateChildren(*this),
+	m_elemDecimalFormats(),
+	m_prefixAliases(),
+	m_namespacesHandler()
+{
+	if (length(m_baseIdent) == 0)
+	{
+		m_includeStack.push_back(m_baseIdent);
+	}
+	else
+	{
+		try
+		{
+			const XalanDOMString urlString = constructionContext.getURLStringFromString(m_baseIdent);
+
+			if (length(urlString) != 0)
+			{
+				m_includeStack.push_back(urlString);
+
+				m_baseIdent = urlString;
+			}
+		}
+		catch(const XMLException&)
+		{
+			// Assume that any exception here relates to get the urlString from
+			// m_baseIdent.  We'll assume that it's just a fake base identifier
+			// since the parser will throw the real error if the base identifier
+			// can't be resolved.
+			m_includeStack.push_back(baseIdentifier);
+		}
+	}
+}
+
+
+
+Stylesheet::~Stylesheet()
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	// Clean up all entries in the imports vector.
+	for_each(m_imports.begin(),
+			 m_imports.end(),
+			 DeleteFunctor<Stylesheet>());
+
+	// Clean up the atribute sets vector
+	for_each(m_attributeSets.begin(),
+			 m_attributeSets.end(),
+			 DeleteFunctor<ElemAttributeSet>());
+
+	// Clean up the top-level variables vector
+	for_each(m_topLevelVariables.begin(),
+			 m_topLevelVariables.end(),
+			 DeleteFunctor<ElemVariable>());
+
+	// Clean up the decimal formats vector
+	for_each(m_elemDecimalFormats.begin(),
+			 m_elemDecimalFormats.end(),
+			 DeleteFunctor<ElemDecimalFormat>());
+
+	// Clean up the extension namespaces vector
+	for_each(m_extensionNamespaces.begin(),
+			 m_extensionNamespaces.end(),
+			 MapValueDeleteFunctor<ExtensionNamespacesMapType>());
+
+	delete m_wrapperlessTemplate;
+
+	delete m_firstTemplate;
+}
+
+
+
+void
+Stylesheet::processKeyElement(
+			ElemTemplateElement*			nsContext,
+			const AttributeList&			atts,
+			StylesheetConstructionContext&	constructionContext)
+{
+	const XalanDOMChar* 	nameAttr = 0;
+	XPath*					matchAttr = 0;
+	XPath*					useAttr = 0;
+ 
+	const unsigned int	nAttrs = atts.getLength();
+
+	for(unsigned int i = 0; i < nAttrs; i++)
+	{
+		const XalanDOMChar* const	aname = atts.getName(i);
+
+		if (equals(aname, Constants::ATTRNAME_NAME))
+		{
+			nameAttr = atts.getValue(i);
+		}
+		else if(equals(aname, Constants::ATTRNAME_MATCH))
+		{
+			matchAttr =
+					constructionContext.createMatchPattern(
+						0,
+						XalanDOMString(atts.getValue(i)),
+						*nsContext);
+		}
+		else if(equals(aname, Constants::ATTRNAME_USE))
+		{
+			useAttr =
+					constructionContext.createXPath(
+						0,
+						atts.getValue(i),
+						*nsContext);
+		}
+		else if (isAttrOK(aname, atts, i, constructionContext) == false)
+		{
+			constructionContext.error(
+				TranscodeFromLocalCodePage("xsl:key, unrecognized keyword '") +
+					aname +
+					TranscodeFromLocalCodePage("'!"));
+		}
+	}
+
+	if(0 == nameAttr)
+		constructionContext.error(TranscodeFromLocalCodePage("xsl:key requires a ") + Constants::ATTRNAME_NAME + " attribute!");
+
+	if(0 == matchAttr)
+		constructionContext.error(TranscodeFromLocalCodePage("xsl:key requires a ") + Constants::ATTRNAME_MATCH + " attribute!");
+
+	if(0 == useAttr)
+		constructionContext.error(TranscodeFromLocalCodePage("xsl:key requires a ") + Constants::ATTRNAME_USE + " attribute!");
+
+	m_keyDeclarations.push_back(KeyDeclaration(XalanDOMString(nameAttr), *matchAttr, *useAttr));
+}
+
+
+
+void
+Stylesheet::pushNamespaces(const AttributeList&		atts)
+{
+	const unsigned int		nAttrs = atts.getLength();
+
+	NamespaceVectorType 	namespaces;
+
+	for(unsigned int i = 0; i < nAttrs; i++)
+	{
+		const XalanDOMChar* const	aname = atts.getName(i);
+		const XalanDOMChar* const	value = atts.getValue(i);
+
+		const bool	isPrefix = startsWith(aname, DOMServices::s_XMLNamespaceWithSeparator);
+
+		if (equals(aname, DOMServices::s_XMLNamespace) || isPrefix) 
+		{
+			const XalanDOMString	p = isPrefix ? substring(aname, 6) : XalanDOMString();
+
+			namespaces.push_back(NameSpace(p, XalanDOMString(value)));
+		}
+	}
+
+	m_namespaces.push_back(namespaces);
+}
+
+
+
+class attrSetCompare
+{
+public:
+
+	attrSetCompare(const ElemAttributeSet&	theAttrSet) :
+		m_attrSet(theAttrSet)
+	{
+	}
+
+	bool
+	operator()(const ElemAttributeSet*	theRHS) const
+	{
+		assert(theRHS != 0);
+
+		return m_attrSet == *theRHS;
+	}
+
+private:
+
+	const ElemAttributeSet&		m_attrSet;
+};
+
+
+
+void
+Stylesheet::postConstruction(StylesheetConstructionContext&		constructionContext)
+{
+	{
+		m_importsSize = m_imports.size();
+
+		// Call postConstruction() on any imported stylesheets, the get any aliases
+		// in reverse order, to preserve import precedence. Also, get any key declarations.
+		const StylesheetVectorType::reverse_iterator	theEnd = m_imports.rend();
+		StylesheetVectorType::reverse_iterator	i = m_imports.rbegin();
+
+		while(i != theEnd)
+		{
+			(*i)->postConstruction(constructionContext);
+
+			m_namespacesHandler.copyNamespaceAliases((*i)->getNamespacesHandler());
+
+			// $$ ToDo: Should we clear the imported stylesheet's key
+			// declarations after we copy them?
+			m_keyDeclarations.insert(
+				m_keyDeclarations.end(),
+				(*i)->m_keyDeclarations.begin(),
+				(*i)->m_keyDeclarations.end());
+
+			++i;
+		}
+	}
+
+	// Call postConstruction() on our own namespaces handler...
+	m_namespacesHandler.postConstruction();
+
+
+	{
+		for (ElemTemplateElement* node = m_firstTemplate;
+			 node != 0;
+			 node = node->getNextSiblingElem())
+		{
+			node->postConstruction(constructionContext, m_namespacesHandler);
+		}
+	}
+
+	{
+		for (ElemVariableVectorType::iterator it = m_topLevelVariables.begin();
+			 it != m_topLevelVariables.end();
+			 ++it)
+		{
+			(*it)->postConstruction(constructionContext, m_namespacesHandler);
+		}
+	}
+
+	{
+		for (ElemTemplateElement* node = m_wrapperlessTemplate;
+			 node != 0;
+			 node = node->getNextSiblingElem())
+		{
+			node->postConstruction(constructionContext, m_namespacesHandler);
+		}
+	}
+
+	{
+#if !defined(XALAN_NO_NAMESPACES)
+		using std::find_if;
+#endif
+		for (AttributeSetVectorType::size_type i = 0; i < m_attributeSets.size(); ++i)
+		{
+			ElemAttributeSet* const		theCurrent = m_attributeSets[i];
+
+			assert(theCurrent != 0);
+
+			for(;;)
+			{
+				// Look for duplicate sets...
+				const AttributeSetVectorType::iterator 	theResult =
+					find_if(
+							m_attributeSets.begin() + (i + 1),
+							m_attributeSets.end(),
+							attrSetCompare(*theCurrent));
+
+				// Did we find it?
+				if(theResult == m_attributeSets.end())
+				{
+					break;
+				}
+				else
+				{
+					theCurrent->adopt(**theResult);
+
+					delete *theResult;
+
+					m_attributeSets.erase(theResult);
+				}
+			}
+
+			theCurrent->postConstruction(constructionContext, m_namespacesHandler);
+		}
+
+		// Now that we're done with removing duplicates, cache the size...
+		m_attributeSetsSize = m_attributeSets.size();
+	}
+
+	// OK, now we need to add everything template that matches "node()"
+	// to the end of the text, comment, and PI template lists.
+	PatternTableListType::iterator	theBegin = m_nodePatternList.begin();
+	PatternTableListType::iterator	theEnd = m_nodePatternList.end();
+
+	if (theBegin != theEnd)
+	{
+		m_textPatternList.insert(
+			m_textPatternList.end(),
+			theBegin,
+			theEnd);
+
+		m_commentPatternList.insert(
+			m_commentPatternList.end(),
+			theBegin,
+			theEnd);
+
+		m_piPatternList.insert(
+			m_piPatternList.end(),
+			theBegin,
+			theEnd);
+	}
+
+	m_nodePatternList.insert(
+			theEnd,
+			m_anyPatternList.begin(),
+			m_anyPatternList.end());
+
+	theBegin = m_nodePatternList.begin();
+	theEnd = m_nodePatternList.end();
+
+	if (theBegin != theEnd)
+	{
+		PatternTableMapType::iterator	i =
+				m_patternTable.begin();
+
+		while(i != m_patternTable.end())
+		{
+			PatternTableListType&	theTable = (*i).second;
+
+			theTable.insert(
+				theTable.end(),
+				theBegin,
+				theEnd);
+
+			++i;
+		}
+	}
+
+	m_patternCount = m_matchPattern2Container.size();
+}
+
+
+
+bool
+Stylesheet::isAttrOK(
+			const XalanDOMChar* 			attrName,
+			const AttributeList&			/* atts */,
+			int 							/* which */,
+			StylesheetConstructionContext&	constructionContext) const
+{
+	// Namespace declarations are OK by definition
+	bool attrOK = equals(attrName, DOMServices::s_XMLNamespace) ||
+						 startsWith(attrName, DOMServices::s_XMLNamespaceWithSeparator);
+
+	if(!attrOK)
+	{
+		// Others are OK if their prefix has been
+		// bound to a non-null Namespace URI other than XSLT's
+		const unsigned int	indexOfNSSep = indexOf(attrName, XalanUnicode::charColon);
+
+		if(indexOfNSSep < length(attrName))
+		{
+			const XalanDOMString	prefix = substring(attrName, 0, indexOfNSSep);
+			const XalanDOMString*	ns = getNamespaceForPrefixFromStack(prefix);
+
+			attrOK = ns != 0 && !::isEmpty(*ns) && !equals(*ns, constructionContext.getXSLTNamespaceURI());
+		}
+		else
+		{
+			attrOK = false;
+		}
+	}
+
+	return attrOK;
+}
+
+
+
+const XalanDOMString*
+Stylesheet::getNamespaceFromStack(const XalanDOMChar* 	nodeName) const
+{
+	assert(nodeName != 0);
+
+	const unsigned int		indexOfNSSep = indexOf(nodeName, XalanUnicode::charColon);
+
+	const XalanDOMString	prefix =
+		indexOfNSSep < length(nodeName) ?
+				substring(nodeName, 0, indexOfNSSep) :
+				XalanDOMString();
+
+	return getNamespaceForPrefixFromStack(prefix);
+}
+
+
+
+bool
+Stylesheet::getYesOrNo(
+			const XalanDOMChar* 			aname,
+			const XalanDOMChar* 			val,
+			StylesheetConstructionContext&	constructionContext) const
+{
+	if(equals(val, Constants::ATTRVAL_YES))
+	{
+		return true;
+	}
+	else if(equals(val, Constants::ATTRVAL_NO))
+	{
+		return false;
+	}
+	else
+	{
+		constructionContext.error(XalanDOMString(val) + " is unknown value for " + aname);
+
+		return false;
+	}
+}
+
+
+
+void
+Stylesheet::addTemplate(
+			ElemTemplate*					theTemplate,
+			StylesheetConstructionContext&	constructionContext)
+{
+	assert(theTemplate != 0);
+
+	unsigned int	pos = 0;
+
+	if(0 == m_firstTemplate)
+	{
+		m_firstTemplate = theTemplate;
+	}
+	else
+	{
+		ElemTemplateElement*	next = m_firstTemplate;
+
+		// Find the last one, then append the new one.
+		while(0 != next)
+		{
+			if(0 == next->getNextSiblingElem())
+			{
+				next->setNextSiblingElem(theTemplate);
+				theTemplate->setNextSiblingElem(0); // just to play it safe.
+				theTemplate->setPreviousSiblingElem(next);
+				break;
+			}
+
+			pos++;
+
+			next = next->getNextSiblingElem();
+		}
+	}
+
+	// If it's a named template, then we need to
+	// and it to the map of named templates.
+	const XalanQName&	theName = theTemplate->getName();
+
+	if(theName.isEmpty() == false)
+	{
+		if (m_namedTemplates.find(theName) == m_namedTemplates.end())
+		{
+			m_namedTemplates[theName] = theTemplate;
+		}
+		else
+		{
+			// This is an error...
+			XalanDOMString	theMessage(TranscodeFromLocalCodePage("The stylesheet already has a template with the name "));
+
+			const XalanDOMString&	theNamespace = theName.getNamespace();
+
+			if (length(theNamespace) != 0)
+			{
+				theMessage += theNamespace;
+				theMessage += DOMServices::s_XMLNamespaceSeparatorString;
+			}
+
+			theMessage += theName.getLocalPart();
+
+			constructionContext.error(theMessage, 0, theTemplate);
+		}
+	}
+
+	// Now, process the match pattern associated with the
+	// template.
+	const XPath* const	xp = theTemplate->getMatchPattern();
+
+	if(0 != xp)
+	{
+		/* Each string has a list of pattern tables associated with it; if the
+		 * string is not in the map, then create a list of pattern tables with one
+		 * entry for the string, otherwise add to the existing pattern table list
+		 * for that string
+		 */
+		typedef XPath::TargetElementStringsVectorType	TargetElementStringsVectorType;
+
+		TargetElementStringsVectorType		strings;
+
+		xp->getTargetElementStrings(strings);
+
+		TargetElementStringsVectorType::size_type	nTargets =
+				strings.size();
+
+		if(nTargets != 0)
+		{
+			for(TargetElementStringsVectorType::size_type stringIndex = 0;
+								stringIndex < nTargets; stringIndex++) 
+			{
+				const XalanDOMString& target = strings[stringIndex];
+
+				m_matchPattern2Container.push_back(
+					MatchPattern2(
+						*theTemplate,
+						pos,
+						target,
+						*xp,
+						xp->getExpression().getCurrentPattern()));
+
+				const MatchPattern2* const	newMatchPat =
+					&m_matchPattern2Container.back();
+
+				// Always put things on the front of the list, so
+				// templates later in the stylesheet are always
+				// selected first.
+				if (equals(target, XPath::PSEUDONAME_TEXT) == true)
+				{
+					m_textPatternList.insert(
+						m_textPatternList.begin(),
+						newMatchPat);
+				}
+				else if (equals(target, XPath::PSEUDONAME_COMMENT) == true)
+				{
+					m_commentPatternList.insert(
+						m_commentPatternList.begin(),
+						newMatchPat);
+				}
+				else if (equals(target, XPath::PSEUDONAME_ROOT) == true)
+				{
+					m_rootPatternList.insert(
+						m_rootPatternList.begin(),
+						newMatchPat);
+				}
+				else if (equals(target, XPath::PSEUDONAME_PI) == true)
+				{
+					m_piPatternList.insert(
+						m_piPatternList.begin(),
+						newMatchPat);
+				}
+				else if (equals(target, XPath::PSEUDONAME_NODE) == true)
+				{
+					m_nodePatternList.insert(
+						m_nodePatternList.begin(),
+						newMatchPat);
+				}
+				else if (equals(target, XPath::PSEUDONAME_ANY) == true)
+				{
+					m_anyPatternList.insert(
+						m_anyPatternList.begin(),
+						newMatchPat);
+				}
+				else
+				{
+					// Put it in the map.
+					PatternTableListType&	theTable =
+						m_patternTable[target];
+
+					theTable.insert(
+						theTable.begin(),
+						newMatchPat);
+				}
+			}
+		}
+	}
+}
+
+
+
+const ElemTemplate*
+Stylesheet::findNamedTemplate(const XalanQName&		qname) const
+{
+	ElemTemplateMapType::const_iterator it = m_namedTemplates.find(qname);
+
+	if(it != m_namedTemplates.end())
+	{
+		return (*it).second;
+	}
+	else
+	{
+		const ElemTemplate*		namedTemplate = 0;
+
+		// Look for the template in the imports
+		const StylesheetVectorType::size_type	nImports = m_imports.size();
+
+		for(StylesheetVectorType::size_type i = 0; i < nImports; ++i)
+		{
+			const Stylesheet* const stylesheet = m_imports[i];
+
+			namedTemplate = stylesheet->findNamedTemplate(qname);
+
+			if(0 != namedTemplate)
+				break;
+		}
+
+		return namedTemplate;
+	}
+}
+	
+
+
+void
+Stylesheet::addObjectIfNotFound(
+			const MatchPattern2*		thePattern,
+			PatternTableVectorType& 	theVector)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::find;
+#endif
+
+	const PatternTableVectorType::const_iterator 	theResult =
+		find(
+				theVector.begin(),
+				theVector.end(),
+				thePattern);
+
+	// Did we find it?
+	if(theResult == theVector.end())
+	{
+		theVector.push_back(thePattern);
+	}
+}
+
+
+
+inline void
+Stylesheet::addObjectIfNotFound(
+			const MatchPattern2*	thePattern,
+			const MatchPattern2* 	thePatternArray[],
+			unsigned int&			thePatternArraySize)
+{
+	if (thePatternArraySize == 0)
+	{
+		thePatternArray[0] = thePattern;
+
+		++thePatternArraySize;
+	}
+	else
+	{
+		unsigned int i = 0;
+
+		while(i < thePatternArraySize)
+		{
+			if (thePatternArray[i] != thePattern)
+			{
+				++i;
+			}
+			else
+			{
+				break;
+			}
+		}
+
+		if (i == thePatternArraySize)
+		{
+			thePatternArray[thePatternArraySize++] = thePattern;
+		}
+	}
+}
+
+
+
+inline const Stylesheet::PatternTableListType* 
+Stylesheet::locateMatchPatternList2(const XalanDOMString&	theName) const
+{
+	assert(m_patternTableEnd == m_patternTable.end());
+
+	const PatternTableMapType::const_iterator	i =
+		m_patternTable.find(theName);
+
+	if (i != m_patternTableEnd)
+	{
+		return &(*i).second;
+	}
+	else
+	{
+		return &m_nodePatternList;
+	}
+}
+
+
+
+inline const Stylesheet::PatternTableListType*
+Stylesheet::locateMatchPatternList2(const XalanNode&	theNode) const
+{
+	switch(theNode.getNodeType())
+	{
+	case XalanNode::ELEMENT_NODE:
+		return locateMatchPatternList2(DOMServices::getLocalNameOfNode(theNode));
+		break;
+
+	case XalanNode::PROCESSING_INSTRUCTION_NODE:
+		return &m_piPatternList;
+		break;
+
+	case XalanNode::ATTRIBUTE_NODE:
+		return locateMatchPatternList2(DOMServices::getLocalNameOfNode(theNode));
+		break;
+
+	case XalanNode::CDATA_SECTION_NODE:
+	case XalanNode::TEXT_NODE:
+		return &m_textPatternList;
+		break;
+
+	case XalanNode::COMMENT_NODE:
+		return &m_commentPatternList;
+		break;
+
+	case XalanNode::DOCUMENT_NODE:
+		return &m_rootPatternList;
+		break;
+
+	case XalanNode::DOCUMENT_FRAGMENT_NODE:
+		return &m_anyPatternList;
+		break;
+	}
+
+	return locateMatchPatternList2(theNode.getNodeName());
+}
+
+
+
+const ElemTemplate*
+Stylesheet::findTemplate(
+			StylesheetExecutionContext& 	executionContext,
+			XalanNode*						targetNode, 
+			const XalanQName&				mode,
+			bool							onlyUseImports) const
+{
+	assert(targetNode != 0);
+	assert(m_patternCount == m_matchPattern2Container.size());
+
+	if(m_isWrapperless == true)
+	{
+		return m_wrapperlessTemplate;
+	}
+	else
+	{
+		const ElemTemplate*		bestMatchedRule = 0;
+		const MatchPattern2*	bestMatchedPattern = 0; // Syncs with bestMatchedRule
+		const double			matchScoreNoneValue = 
+			XPath::getMatchScoreValue(XPath::eMatchScoreNone);
+
+		double					bestMatchPatPriority = matchScoreNoneValue;
+			
+
+		unsigned int			nConflicts = 0;
+
+		// Use a stack-based array when possible...
+		const MatchPattern2*	conflictsArray[100];
+
+		XalanArrayAutoPtr<const MatchPattern2*>		conflictsVector;
+
+		const MatchPattern2**	conflicts = 0;
+
+		if(onlyUseImports == false)
+		{
+			// Points to the current list of match patterns.  Note
+			// that this may point to more than one table.
+			const PatternTableListType* 	matchPatternList =
+				locateMatchPatternList2(*targetNode);
+			assert(matchPatternList != 0);
+
+			PatternTableListType::const_iterator		theCurrentEntry =
+				matchPatternList->begin();
+
+			const PatternTableListType::const_iterator	theTableEnd =
+				matchPatternList->end();
+
+			if (theCurrentEntry != theTableEnd)
+			{
+				const XalanDOMString*	prevPat = 0;
+				const MatchPattern2*	prevMatchPat = 0;
+				double					prevMatchPatPriority = matchScoreNoneValue;
+
+				do
+				{
+					const MatchPattern2*	matchPat = *theCurrentEntry;
+					double					matchPatPriority = matchScoreNoneValue;
+					assert(matchPat != 0);
+
+					const ElemTemplate*	const	rule = matchPat->getTemplate();
+					assert(rule != 0);
+
+					// We'll be needing to match rules according to what 
+					// mode we're in.
+					const XalanQName&	ruleMode = rule->getMode();
+
+					// The logic here should be that if we are not in a mode AND
+					// the rule does not have a node, then go ahead.
+					// OR if we are in a mode, AND the rule has a node, 
+					// AND the rules match, then go ahead.
+					const bool	haveMode = !mode.isEmpty();
+					const bool	haveRuleMode = !ruleMode.isEmpty();
+
+					if ((!haveMode && !haveRuleMode) ||
+						(haveMode && haveRuleMode && ruleMode.equals(mode)))
+					{
+						const XalanDOMString*	patterns = matchPat->getPattern();
+						assert(patterns != 0);
+
+						if(!isEmpty(*patterns) &&
+						   !(prevMatchPat != 0 &&
+							 (prevPat != 0 && equals(*prevPat, *patterns)) &&
+							 prevMatchPat->getTemplate()->getPriority() == matchPat->getTemplate()->getPriority()))
+						{
+							prevPat = patterns;
+							prevMatchPat = matchPat;
+							prevMatchPatPriority = matchPatPriority;
+							matchPatPriority = matchScoreNoneValue;
+
+							const XPath* const	xpath = matchPat->getExpression();
+
+							XPath::eMatchScore	score =
+									xpath->getMatchScore(targetNode, *this, executionContext);
+
+							if(XPath::eMatchScoreNone != score)
+							{
+								const double priorityVal = rule->getPriority();
+								const double priorityOfRule 
+										  = (matchScoreNoneValue != priorityVal) 
+										  ? priorityVal : XPath::getMatchScoreValue(score);
+
+								matchPatPriority = priorityOfRule;
+								const double priorityOfBestMatched =
+											(0 != bestMatchedPattern) ?
+													bestMatchPatPriority : 
+													matchScoreNoneValue;
+
+								if(priorityOfRule > priorityOfBestMatched)
+								{
+									nConflicts = 0;
+
+									bestMatchedRule = rule;
+									bestMatchedPattern = matchPat;
+									bestMatchPatPriority = matchPatPriority;
+								}
+								else if(priorityOfRule == priorityOfBestMatched)
+								{
+									if (conflicts == 0)
+									{
+										if (m_patternCount > sizeof(conflictsArray) / sizeof(conflictsArray[0]))
+										{
+											conflictsVector.reset(new const MatchPattern2*[m_patternCount]);
+
+											conflicts = conflictsVector.get();
+										}
+										else
+										{
+											conflicts = conflictsArray;
+										}
+									}
+
+									assert(conflicts != 0);
+
+									// Add the best matched pattern so far.
+									addObjectIfNotFound(bestMatchedPattern, conflicts, nConflicts);
+
+									// Add the pattern that caused the conflict...
+									conflicts[nConflicts++] = matchPat;
+
+									bestMatchedRule = rule;
+									bestMatchedPattern = matchPat;
+									bestMatchPatPriority = matchPatPriority;
+								}
+							}
+						}
+					}
+
+					++theCurrentEntry;
+
+				} while(theCurrentEntry != theTableEnd);
+			}
+		} // end if(useImports == false)
+
+		if(0 == bestMatchedRule)
+		{
+			assert(m_importsSize == m_imports.size());
+
+			for(unsigned int i = 0; i < m_importsSize; i++)
+			{
+				const Stylesheet* const 	stylesheet =
+					m_imports[i];
+
+				bestMatchedRule = stylesheet->findTemplate(executionContext,
+														   targetNode,
+														   mode, 
+														   false);
+				if(0 != bestMatchedRule)
+					break;
+			}
+		}
+
+		if(nConflicts > 0)
+		{
+			assert(conflicts != 0);
+
+			const bool		quietConflictWarnings = executionContext.getQuietConflictWarnings();
+
+			XalanDOMString	conflictsString;
+			
+			if (quietConflictWarnings == false)
+			{
+				conflictsString = XALAN_STATIC_UCODE_STRING("Specificity conflicts found: ");
+			}
+
+			for(unsigned int i = 0; i < nConflicts; i++)
+			{
+				const MatchPattern2* const	conflictPat = conflicts[i];
+
+				if(0 != i)
+				{
+					if(quietConflictWarnings == false)
+					{
+						conflictsString += XALAN_STATIC_UCODE_STRING(", ");
+					}
+					// Find the furthest one towards the bottom of the document.
+					if(conflictPat->getPositionInStylesheet() >
+						bestMatchedPattern->getPositionInStylesheet())
+					{
+						bestMatchedPattern = conflictPat;
+					}
+				}
+				else
+				{
+					bestMatchedPattern = conflictPat;
+				}
+
+				if(quietConflictWarnings == false)
+				{
+					conflictsString += XalanDOMString(XALAN_STATIC_UCODE_STRING("\"")) +
+										*conflictPat->getPattern() +
+										XalanDOMString(XALAN_STATIC_UCODE_STRING("\""));
+				}
+			}
+
+			bestMatchedRule = bestMatchedPattern->getTemplate();
+
+			if(quietConflictWarnings == false)
+			{
+				conflictsString += XALAN_STATIC_UCODE_STRING(" ");
+				conflictsString += XALAN_STATIC_UCODE_STRING("Last found in stylesheet will be used.");
+				executionContext.warn(conflictsString);
+			}
+		}
+
+		return bestMatchedRule;
+	}
+}
+
+
+
+void
+Stylesheet::addExtensionNamespace(
+			const XalanDOMString&	uri,
+			ExtensionNSHandler*		nsh)
+{
+	m_extensionNamespaces.insert(ExtensionNamespacesMapType::value_type(uri, nsh));
+
+	m_namespacesHandler.addExtensionNamespaceURI(uri);
+}
+
+
+
+void
+Stylesheet::pushTopLevelVariables(
+			StylesheetExecutionContext& 	executionContext,
+			const ParamVectorType&			topLevelParams) const
+{
+	{
+		// First, push any imports...
+		const StylesheetVectorType::const_reverse_iterator	rend = m_imports.rend();
+
+		for(StylesheetVectorType::const_reverse_iterator i = m_imports.rbegin(); i != rend; ++i)
+		{
+			const Stylesheet* const stylesheet = *i;
+			assert(stylesheet != 0);
+
+			stylesheet->pushTopLevelVariables(executionContext, topLevelParams);
+		}
+	}
+
+	const ParamVectorType::size_type	nVars = m_topLevelVariables.size();
+
+	for(ParamVectorType::size_type i = 0; i < nVars; ++i)
+	{
+		ElemVariable* const 	var = m_topLevelVariables[i];
+
+		bool					isParam =
+				Constants::ELEMNAME_PARAMVARIABLE == var->getXSLToken();
+
+		if(isParam == true)
+		{
+			isParam = false;
+
+			const ParamVectorType::size_type	n = topLevelParams.size();
+
+			for(ParamVectorType::size_type k = 0; k < n; k++)
+			{
+				const ParamVectorType::value_type&	arg = topLevelParams[k];
+
+				if(arg.getName().equals(var->getName()))
+				{
+					isParam = true;
+
+					if (arg.getXObject().null() == false)
+					{
+						executionContext.pushVariable(
+							arg.getName(),
+							arg.getXObject(),
+							0);
+					}
+					else
+					{
+						executionContext.pushVariable(
+							arg.getName(),
+							0,
+							arg.getExpression(),
+							executionContext.getRootDocument(),
+							*this);
+					}
+
+					break;
+				}
+			}
+		}
+
+		if (isParam == false)
+		{
+			executionContext.pushVariable(var->getName(),
+										  var,
+										  var->getParentNodeElem());
+		}
+	}
+}
+
+
+
+void
+Stylesheet::processNSAliasElement(
+			const XalanDOMChar*				name,
+			const AttributeList&			atts,
+			StylesheetConstructionContext&	constructionContext)
+{
+	const unsigned int		nAttrs = atts.getLength();
+
+	const XalanDOMString*	stylesheetNamespace = &DOMServices::s_emptyString;
+	const XalanDOMString*	resultNamespace = &DOMServices::s_emptyString;
+	const XalanDOMString	dummy;
+
+	for(unsigned int i = 0; i < nAttrs; i++)
+	{
+		const XalanDOMChar* const	aname = atts.getName(i);
+
+		if(equals(aname, Constants::ATTRNAME_STYLESHEET_PREFIX) == true)
+		{
+			const XalanDOMChar* const	value = atts.getValue(i);
+
+			if (equals(value, Constants::ATTRVAL_DEFAULT_PREFIX) == true)
+			{
+				stylesheetNamespace = getNamespaceForPrefix(dummy);
+			}
+			else
+			{
+				stylesheetNamespace = getNamespaceForPrefix(XalanDOMString(value));
+			}
+		}
+		else if(equals(aname, Constants::ATTRNAME_RESULT_PREFIX))
+		{
+			const XalanDOMChar* const	value = atts.getValue(i);
+
+			if (equals(value, Constants::ATTRVAL_DEFAULT_PREFIX) == true)
+			{
+				resultNamespace = getNamespaceForPrefix(dummy);
+			}
+			else
+			{
+				resultNamespace = getNamespaceForPrefix(XalanDOMString(value));
+			}
+		}
+		else if(!isAttrOK(aname, atts, i, constructionContext))
+		{
+			constructionContext.error(XalanDOMString(name) + " has an illegal attribute: " + aname);
+		}
+	}
+
+	// Build a table of aliases, the key is the stylesheet uri and the
+	// value is the result uri
+	if (length(*stylesheetNamespace) == 0 ||
+		length(*resultNamespace) == 0)
+	{
+		constructionContext.error("Missing namespace URI for specified prefix");
+	}
+	else
+	{
+#if 1
+		// $$$ ToDo: Enable other code.  Perhaps an error?
+		m_prefixAliases[*stylesheetNamespace] = *resultNamespace;
+
+		m_namespacesHandler.setNamespaceAlias(*stylesheetNamespace, *resultNamespace);
+#else
+		const PrefixAliasesMapType::iterator	i =
+			m_prefixAliases.find(*stylesheetNamespace);
+
+		if (i != m_prefixAliases.end())
+		{
+			// $$$ ToDo: This could also be an error?
+			(*i).second = *resultNamespace;
+		}
+		else
+		{
+			m_prefixAliases.insert(PrefixAliasesMapType::value_type(*stylesheetNamespace, *resultNamespace));
+		}
+#endif
+	}
+}
+
+
+
+XalanDOMString
+Stylesheet::getAliasNamespaceURI(const XalanDOMChar*	uri) const
+{
+	assert(uri != 0);
+
+	return getAliasNamespaceURI(XalanDOMString(uri));
+}
+
+
+
+XalanDOMString
+Stylesheet::getAliasNamespaceURI(const XalanDOMString&	uri) const
+{
+	const StringToStringMapType::const_iterator	i =
+		m_prefixAliases.find(uri);
+
+	if (i != m_prefixAliases.end())
+	{
+		assert(length((*i).second) > 0);
+
+		return (*i).second;
+	}
+	else
+	{
+		XalanDOMString	theResult;
+
+		const StylesheetVectorType::size_type	nImports =
+			m_imports.size();
+
+		for(StylesheetVectorType::size_type i = 0; i < nImports; ++i)
+		{
+			theResult = m_imports[i]->getAliasNamespaceURI(uri);
+
+			if(length(theResult) != 0)
+			{
+				break;
+			}
+		}
+
+		return theResult;
+	}
+}
+
+
+
+const XalanDecimalFormatSymbols*
+Stylesheet::getDecimalFormatSymbols(const XalanDOMString&	name) const
+{
+	const XalanDecimalFormatSymbols* 				dfs = 0;
+
+	const ElemDecimalFormatVectorType::size_type	theSize =
+		m_elemDecimalFormats.size();
+
+	if(theSize > 0)
+	{
+		// Start from the top of the stack
+		for (int i = theSize - 1; i >= 0; --i)
+		{
+			assert(m_elemDecimalFormats[i] != 0);
+
+			if (equals(m_elemDecimalFormats[i]->getName(), name) == true)
+			{
+				dfs = &m_elemDecimalFormats[i]->getDecimalFormatSymbols();
+
+				break;
+			}
+		}
+	}
+
+	// If dfs is null at this point, it should
+	// mean there wasn't an xsl:decimal-format declared
+	// with the given name.	So go up the import hierarchy
+	// and see if one of the imported stylesheets declared
+	// it.
+	if(dfs == 0)
+	{
+		for(StylesheetVectorType::size_type i = 0; i < m_importsSize; ++i)
+		{
+			dfs = m_imports[i]->getDecimalFormatSymbols(name);
+
+			if(dfs != 0)
+			{
+				break;
+			}
+		}
+	}
+
+	return dfs;
+}
+
+
+
+void
+Stylesheet::applyAttrSets(
+			const QNameVectorType&			attributeSetsNames,
+			StylesheetExecutionContext& 	executionContext,			
+			XalanNode*						sourceNode) const
+{
+	const QNameVectorType::size_type	nNames = attributeSetsNames.size();
+
+	if(0 != nNames)
+	{
+		assert(m_importsSize == m_imports.size());
+
+		// Process up the import chain...
+		for(StylesheetVectorType::size_type i = 0; i < m_importsSize; i++)
+		{
+			const Stylesheet* const 	stylesheet = m_imports[i];
+
+			stylesheet->applyAttrSets(
+				attributeSetsNames, 
+				executionContext,
+				sourceNode);
+		}
+
+		for(QNameVectorType::size_type j = 0; j < nNames; j++)
+		{
+			const XalanQName&	qname = attributeSetsNames[j];
+
+			assert(m_attributeSetsSize == m_attributeSets.size());
+
+			for(StylesheetVectorType::size_type k = 0; k < m_attributeSetsSize; k++)
+			{
+				const ElemAttributeSet* const	attrSet = m_attributeSets[k];
+				assert(attrSet != 0);
+
+				if(qname.equals(attrSet->getQName()))
+				{
+					attrSet->execute(executionContext);
+				}
+			}
+		}
+	}
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getNodeName() const
+{
+	return s_emptyString;
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getNodeValue() const
+{
+	return s_emptyString;
+}
+
+
+
+Stylesheet::NodeType
+Stylesheet::getNodeType() const
+{
+	return XalanNode::DOCUMENT_NODE;
+}
+
+
+
+XalanNode*
+Stylesheet::getParentNode() const
+{
+	return 0;
+}
+
+
+
+const XalanNodeList*
+Stylesheet::getChildNodes() const
+{
+	return &m_surrogateChildren;
+}
+
+
+
+XalanNode*
+Stylesheet::getFirstChild() const
+{
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::getLastChild() const
+{
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::getPreviousSibling() const 
+{
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::getNextSibling() const 
+{
+	return 0;
+}
+
+
+
+const XalanNamedNodeMap*
+Stylesheet::getAttributes() const
+{
+	return &s_fakeAttributes;
+}
+
+
+
+XalanDocument*
+Stylesheet::getOwnerDocument() const
+{
+	return 0;
+}
+
+
+
+#if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
+XalanNode*
+#else
+Stylesheet*
+#endif
+Stylesheet::cloneNode(bool		/* deep */) const
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::insertBefore(
+			XalanNode*	/* newChild */,
+			XalanNode*	/* refChild */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::replaceChild(
+			XalanNode*	/* newChild */,
+			XalanNode*	/* oldChild */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::removeChild(XalanNode*		/* oldChild */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::appendChild(XalanNode*		/* oldChild */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+bool
+Stylesheet::hasChildNodes() const
+{
+	// $$$ ToDo: Is this always true?
+	return true;
+}
+
+
+
+void
+Stylesheet::setNodeValue(const XalanDOMString&		/* nodeValue */)
+{
+	throw XalanDOMException(XalanDOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+
+void
+Stylesheet::normalize()
+{
+}
+
+
+
+bool
+Stylesheet::supports(
+			const XalanDOMString&	/* feature */,
+			const XalanDOMString&	/* version */) const
+{
+	return false;
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getNamespaceURI() const
+{
+	// $$ ToDo: Is this the same value as PrefixResolver::getURI()?
+	return s_emptyString;
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getPrefix() const
+{
+	return s_emptyString;
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getLocalName() const
+{
+	return s_emptyString;
+}
+
+
+
+void
+Stylesheet::setPrefix(const XalanDOMString& /* prefix */)
+{
+	throw XalanDOMException(XalanDOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+
+unsigned long
+Stylesheet::getIndex() const
+{
+	return 0;
+}
+
+
+
+XalanElement*
+Stylesheet::createElement(const XalanDOMString& 	/* tagName */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanDocumentFragment*
+Stylesheet::createDocumentFragment()
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanText*
+Stylesheet::createTextNode(const XalanDOMString&	/* data */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanComment*
+Stylesheet::createComment(const XalanDOMString& 	/* data */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanCDATASection*
+Stylesheet::createCDATASection(const XalanDOMString&	/* data */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanProcessingInstruction*
+Stylesheet::createProcessingInstruction(
+			const XalanDOMString&	/* target */,
+			const XalanDOMString&	/* data */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanAttr*
+Stylesheet::createAttribute(const XalanDOMString&	/* name */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanEntityReference*
+Stylesheet::createEntityReference(const XalanDOMString& 	/* name */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanDocumentType*
+Stylesheet::getDoctype() const
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanDOMImplementation*
+Stylesheet::getImplementation() const
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanElement*
+Stylesheet::getDocumentElement() const
+{
+	// $$$ ToDo: Is this correct?
+
+	return m_wrapperlessTemplate != 0 ? m_wrapperlessTemplate : m_firstTemplate;
+}
+
+
+
+XalanNodeList*
+Stylesheet::getElementsByTagName(const XalanDOMString&		/* name */) const
+{
+	return 0;
+}
+
+
+
+XalanNodeList*
+Stylesheet::getElementsByTagNameNS(
+			const XalanDOMString&	/* namespaceURI */,
+			const XalanDOMString&	/* localName */) const
+{
+	return 0;
+}
+
+
+
+XalanNode*
+Stylesheet::importNode(
+			XalanNode*	/* importedNode */,
+			bool		/* deep */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanElement*
+Stylesheet::createElementNS(
+			const XalanDOMString&	/* namespaceURI */,
+			const XalanDOMString&	/* qualifiedName */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanAttr*
+Stylesheet::createAttributeNS(
+			const XalanDOMString&	/* namespaceURI */,
+			const XalanDOMString&	/* qualifiedName */)
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+XalanElement*
+Stylesheet::getElementById(const XalanDOMString&	/* elementId */) const
+{
+	//should not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+bool
+Stylesheet::isIndexed() const
+{
+	// This member functionshould not be called
+	assert(false);	
+
+	return false;
+}
+
+
+
+unsigned long
+Stylesheet::getNumber() const
+{
+	// This member functionshould not be called
+	assert(false);	
+
+	return 0;
+}
+
+
+
+const XalanDOMString*
+Stylesheet::getNamespaceForPrefix(const XalanDOMString& 	prefix) const
+{
+	return XalanQName::getNamespaceForPrefix(m_namespaceDecls, prefix);
+}
+
+
+
+const XalanDOMString&
+Stylesheet::getURI() const
+{
+	return m_baseIdent;
+}
diff --git a/src/XSLT/XSLTEngineImpl.cpp b/src/XSLT/XSLTEngineImpl.cpp
new file mode 100644
index 0000000..5ce03dd
--- /dev/null
+++ b/src/XSLT/XSLTEngineImpl.cpp
@@ -0,0 +1,3349 @@
+/*
+ * 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/>.
+ */
+
+
+
+// Class header file.
+#include "XSLTEngineImpl.hpp"
+
+
+
+#include <sax/DocumentHandler.hpp>
+#include <sax/EntityResolver.hpp>
+#include <sax/Locator.hpp>
+#include <sax/SAXException.hpp>
+#include <util/PlatformUtils.hpp>
+#include <framework/URLInputSource.hpp>
+
+
+
+#include <Include/STLHelper.hpp>
+
+
+
+#include <XalanDOM/XalanDOMException.hpp>
+#include <XalanDOM/XalanNode.hpp>
+#include <XalanDOM/XalanAttr.hpp>
+#include <XalanDOM/XalanComment.hpp>
+#include <XalanDOM/XalanCDATASection.hpp>
+#include <XalanDOM/XalanNodeList.hpp>
+#include <XalanDOM/XalanNamedNodeMap.hpp>
+#include <XalanDOM/XalanProcessingInstruction.hpp>
+#include <XalanDOM/XalanText.hpp>
+
+
+
+#include <PlatformSupport/PrintWriter.hpp>
+#include <PlatformSupport/StringTokenizer.hpp>
+#include <PlatformSupport/XalanUnicode.hpp>
+
+
+
+#include <DOMSupport/DOMServices.hpp>
+#include <DOMSupport/DOMSupport.hpp>
+
+
+
+#include <XMLSupport/FormatterToDOM.hpp>
+#include <XMLSupport/FormatterToText.hpp>
+#include <XMLSupport/FormatterToXML.hpp>
+#include <XMLSupport/FormatterToHTML.hpp>
+#include <XMLSupport/FormatterTreeWalker.hpp>
+#include <XMLSupport/XMLParserLiaison.hpp>
+#include <XMLSupport/FormatterTreeWalker.hpp>
+
+
+
+#include <XPath/ElementPrefixResolverProxy.hpp>
+#include <XPath/XalanQNameByReference.hpp>
+#include <XPath/ResultTreeFrag.hpp>
+#include <XPath/XObject.hpp>
+#include <XPath/XObjectFactory.hpp>
+#include <XPath/XPathEnvSupport.hpp>
+#include <XPath/XPathEnvSupportDefault.hpp>
+#include <XPath/XPathExecutionContextDefault.hpp>
+#include <XPath/XPathFactory.hpp>
+#include <XPath/XPathProcessorImpl.hpp>
+#include <XPath/XResultTreeFrag.hpp>
+
+
+
+#include "Constants.hpp"
+#include "ElemWithParam.hpp"
+#include "FunctionCurrent.hpp"
+#include "FunctionDocument.hpp"
+#include "FunctionElementAvailable.hpp"
+#include "FunctionFunctionAvailable.hpp"
+#include "FunctionFormatNumber.hpp"
+#include "FunctionGenerateID.hpp"
+#include "FunctionKey.hpp"
+#include "FunctionSystemProperty.hpp"
+#include "FunctionUnparsedEntityURI.hpp"
+#include "GenerateEvent.hpp"
+#include "ProblemListener.hpp"
+#include "ProblemListenerDefault.hpp"
+#include "Stylesheet.hpp"
+#include "StylesheetConstructionContext.hpp"
+#include "StylesheetExecutionContext.hpp"
+#include "StylesheetHandler.hpp"
+#include "StylesheetRoot.hpp"
+#include "TraceListener.hpp"
+#include "XSLTInputSource.hpp"
+#include "XSLTProcessorException.hpp"
+#include "XSLTResultTarget.hpp"
+
+
+
+//#define XALAN_VQ_SPECIAL_TRACE
+#if defined(XALAN_VQ_SPECIAL_TRACE)
+#include "C:/Program Files/Rational/Quantify/pure.h"
+#endif
+
+
+
+const XalanDOMString	XSLTEngineImpl::s_emptyString;
+
+
+
+//==========================================================
+// SECTION: Constructors
+//==========================================================
+
+XSLTEngineImpl::XSLTEngineImpl(
+			XMLParserLiaison&	parserLiaison,
+			XPathEnvSupport&	xpathEnvSupport,
+			DOMSupport&			domSupport,
+			XObjectFactory&		xobjectFactory,
+			XPathFactory&		xpathFactory) :
+	XSLTProcessor(),
+	DocumentHandler(),
+	PrefixResolver(),
+	m_useDOMResultTreeFactory(false),
+	m_domResultTreeFactory(0),
+	m_resultNameSpacePrefix(),
+	m_resultNameSpaceURL(),
+	m_xpathFactory(xpathFactory),
+	m_xobjectFactory(xobjectFactory),
+	m_xpathProcessor(new XPathProcessorImpl),
+	m_cdataStack(),
+	m_stylesheetLocatorStack(),
+	m_defaultProblemListener(),
+	m_problemListener(&m_defaultProblemListener),
+	m_stylesheetRoot(0),
+	m_traceSelects(false),
+	m_quietConflictWarnings(false),
+	m_diagnosticsPrintWriter(0),
+	m_durationsTable(),
+	m_traceListeners(),
+	m_uniqueNSValue(0),
+	m_topLevelParams(),
+	m_parserLiaison(parserLiaison),
+	m_xpathEnvSupport(xpathEnvSupport),
+	m_domSupport(domSupport),
+	m_executionContext(0),
+	m_outputContextStack(),
+	m_resultNamespacesStack(),
+	m_dummyAttributesList()
+{
+	m_outputContextStack.pushContext();
+}
+
+
+
+void
+XSLTEngineImpl::reset()
+{
+	m_topLevelParams.clear();
+	m_durationsTable.clear();
+	m_stylesheetLocatorStack.clear();
+	m_cdataStack.clear();
+
+	if (m_domResultTreeFactory != 0)
+	{
+		m_parserLiaison.destroyDocument(m_domResultTreeFactory);
+		m_domResultTreeFactory = 0;
+	}
+
+	m_stylesheetRoot = 0;
+
+	m_outputContextStack.reset();
+
+	m_outputContextStack.pushContext();
+
+	m_xpathEnvSupport.reset();
+	m_xpathFactory.reset();
+	m_xobjectFactory.reset();
+	m_domSupport.reset();
+
+	m_resultNamespacesStack.clear();
+}
+
+
+
+XSLTEngineImpl::~XSLTEngineImpl()
+{
+	reset();
+}
+
+
+
+//==========================================================
+// SECTION: Main API Functions
+//==========================================================
+
+
+
+static const XalanDOMChar	s_dummyString = 0;
+
+
+void
+XSLTEngineImpl::process(
+			const XSLTInputSource&			inputSource, 
+	        const XSLTInputSource&			stylesheetSource,
+	        XSLTResultTarget&				outputTarget,
+			StylesheetConstructionContext&	constructionContext,
+			StylesheetExecutionContext&		executionContext)
+{
+	XalanDOMString	xslIdentifier;
+
+	if (0 == stylesheetSource.getSystemId())
+	{
+		xslIdentifier = XalanDOMString(XALAN_STATIC_UCODE_STRING("Input XSL"));
+	}
+	else
+	{
+		xslIdentifier = stylesheetSource.getSystemId();
+	}
+
+	bool totalTimeID = true;
+
+	pushTime(&totalTimeID);
+
+	XalanNode*	sourceTree = getSourceTreeFromInput(inputSource);
+
+	m_stylesheetRoot = processStylesheet(stylesheetSource, constructionContext);
+
+	if(0 != sourceTree && m_stylesheetRoot == 0)
+	{
+		// Didn't get a stylesheet from the input source, so look for a
+		// stylesheet processing instruction...
+		XalanDOMString			stylesheetURI;
+
+		// The PI must be a child of the document...
+		XalanNode*				child = sourceTree->getFirstChild();
+
+#if !defined(XALAN_NO_NAMESPACES)
+		using std::vector;
+#endif
+
+		vector<XalanDOMString>	hrefs;
+
+		// $$$ ToDo: is this first one style valid?
+		const XalanDOMString	stylesheetNodeName1(XALAN_STATIC_UCODE_STRING("xml-stylesheet"));
+		const XalanDOMString	stylesheetNodeName2(XALAN_STATIC_UCODE_STRING("xml:stylesheet"));
+
+		// $$$ ToDo: This code is much like that in getStyleSheetURIFromDoc().
+		// Why is it repeated???
+		// $$$ ToDo: Move these embedded strings from inside these loops
+		// out here...
+		// $$$ ToDo: These loops are a mess of repeated use of the
+		// same data values.
+		while(child != 0)
+		{
+			if(XalanNode::PROCESSING_INSTRUCTION_NODE == child->getNodeType())
+			{
+				const XalanDOMString	nodeName(child->getNodeName());
+
+				if(equals(nodeName, stylesheetNodeName1) ||
+				   equals(nodeName, stylesheetNodeName2))
+				{
+					bool isOK = true;
+
+					StringTokenizer 	tokenizer(child->getNodeValue(), XALAN_STATIC_UCODE_STRING(" \t="));
+
+					while(tokenizer.hasMoreTokens())
+					{
+						if(equals(tokenizer.nextToken(), XALAN_STATIC_UCODE_STRING("type")))
+						{
+							XalanDOMString	typeVal = tokenizer.nextToken();
+
+							typeVal = substring(typeVal, 1, length(typeVal) - 1);
+
+							if(!equals(typeVal, XALAN_STATIC_UCODE_STRING("text/xsl")))
+							{
+								isOK = false;
+							}
+						}
+					}	
+						
+					if(isOK)
+					{
+						StringTokenizer 	tokenizer(child->getNodeValue(), XALAN_STATIC_UCODE_STRING(" \t="));
+
+						while(tokenizer.hasMoreTokens())
+						{
+							const XalanDOMString	theCurrentToken = tokenizer.nextToken();
+
+							if(equals(theCurrentToken, XALAN_STATIC_UCODE_STRING("href")))
+							{
+								stylesheetURI = tokenizer.nextToken();
+								stylesheetURI = substring(stylesheetURI, 1, length(stylesheetURI) - 1);
+								hrefs.push_back(stylesheetURI);
+							}
+						}
+					}
+				}
+			}
+
+			child = child->getNextSibling();
+		}
+
+		bool isRoot = true;
+		Stylesheet* prevStylesheet = 0;
+			
+		if (hrefs.empty() == false)
+		{
+			const XalanDOMChar* const	pxch = inputSource.getSystemId();
+
+			const XalanDOMString		sysid(pxch == 0 ? &s_dummyString : pxch); 
+
+			do
+			{
+				const XalanDOMString&	ref =  hrefs.back();
+
+				Stylesheet* stylesheet =
+							getStylesheetFromPIURL(
+								ref,
+								*sourceTree,
+								sysid,
+								isRoot,
+								constructionContext);
+
+				if(false == isRoot)
+				{
+					prevStylesheet->addImport(stylesheet, false);
+				}
+
+				prevStylesheet = stylesheet;
+				isRoot = false;
+				hrefs.pop_back();
+			} while(!hrefs.empty());
+		}
+	}
+
+	if(0 == m_stylesheetRoot)
+	{
+		error("Failed to process stylesheet!");
+	}
+	else if(0 != sourceTree)
+	{
+		executionContext.setStylesheetRoot(m_stylesheetRoot);
+
+		FormatterListener* const	theFormatter =
+				outputTarget.getDocumentHandler();
+
+		if (theFormatter != 0)
+		{
+			theFormatter->setPrefixResolver(this);
+		}
+
+		m_stylesheetRoot->process(sourceTree, outputTarget, executionContext);
+
+		if(0 != m_diagnosticsPrintWriter)
+		{
+			displayDuration(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("Total time")), &totalTimeID);
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::process(
+			const XSLTInputSource&			inputSource, 
+	        XSLTResultTarget&				outputTarget,
+			StylesheetExecutionContext&		executionContext)
+{
+	bool	totalTimeID = true;
+
+	if(0 != m_diagnosticsPrintWriter)
+	{
+		pushTime(&totalTimeID);
+	}
+
+	XalanNode* const	sourceTree = getSourceTreeFromInput(inputSource);
+
+	if(0 != sourceTree)
+	{
+		if (m_stylesheetRoot == 0)
+		{
+			error("No stylesheet is available to process!");
+		}
+
+		FormatterListener* const	theFormatter =
+				outputTarget.getDocumentHandler();
+
+		if (theFormatter != 0)
+		{
+			theFormatter->setPrefixResolver(this);
+		}
+
+		m_stylesheetRoot->process(sourceTree, outputTarget, executionContext);
+	}
+
+	if(0 != m_diagnosticsPrintWriter)
+	{
+		displayDuration(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("Total time")), &totalTimeID);
+	}
+}
+
+
+
+StylesheetRoot*
+XSLTEngineImpl::processStylesheet(
+			const XalanDOMString&			xsldocURLString,
+			StylesheetConstructionContext&	constructionContext)
+{
+	const XSLTInputSource	input(c_wstr(xsldocURLString));
+
+	return processStylesheet(input, constructionContext);
+}
+
+
+
+StylesheetRoot*
+XSLTEngineImpl::processStylesheet(
+  			const XSLTInputSource&			stylesheetSource,
+			StylesheetConstructionContext&	constructionContext)
+{
+	StylesheetRoot*		theStylesheet = 0;
+
+	const XalanDOMChar* const	systemID = stylesheetSource.getSystemId();
+	XalanNode* const			stylesheetNode = stylesheetSource.getNode();
+
+	if (systemID != 0 || stylesheetNode != 0 || stylesheetSource.getStream() != 0)
+	{
+		XalanDOMString	xslIdentifier;
+
+		theStylesheet = constructionContext.create(stylesheetSource);
+
+		StylesheetHandler	stylesheetProcessor(*theStylesheet, constructionContext);
+
+		if(stylesheetNode != 0)
+		{
+			xslIdentifier = XALAN_STATIC_UCODE_STRING("Input XSL");
+
+			FormatterTreeWalker tw(stylesheetProcessor);
+
+			tw.traverse(stylesheetSource.getNode());
+		}
+		else
+		{
+			if (systemID != 0)
+			{
+				xslIdentifier = systemID;
+			}
+
+			diag(XALAN_STATIC_UCODE_STRING("========= Parsing ") + xslIdentifier + XALAN_STATIC_UCODE_STRING(" =========="));
+
+			pushTime(&xslIdentifier);
+
+			m_parserLiaison.parseXMLStream(stylesheetSource,
+										   stylesheetProcessor);
+
+			if(0 != m_diagnosticsPrintWriter)
+				displayDuration(XALAN_STATIC_UCODE_STRING("Parse of ") + xslIdentifier, &xslIdentifier);
+		}
+
+		theStylesheet->postConstruction(constructionContext);
+	}
+
+	return theStylesheet;
+}
+
+
+
+//==========================================================
+// SECTION: XML Parsing Functions
+//==========================================================
+
+XalanNode*
+XSLTEngineImpl::getSourceTreeFromInput(const XSLTInputSource&	inputSource)
+{
+	XalanNode*		sourceTree = inputSource.getNode();
+
+	if(0 == sourceTree)
+	{
+		const XalanDOMString	xmlIdentifier = 0 != inputSource.getSystemId() ?
+												XalanDOMString(inputSource.getSystemId()) :
+												StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("Input XML"));
+
+		// In case we have a fragment identifier, go ahead and 
+		// try to parse the XML here.
+		diag(XALAN_STATIC_UCODE_STRING("========= Parsing ") +
+					xmlIdentifier +
+					XALAN_STATIC_UCODE_STRING(" =========="));
+
+		pushTime(&xmlIdentifier);
+
+#if defined(XALAN_VQ_SPECIAL_TRACE)
+		QuantifyStartRecordingData();
+#endif
+
+		XalanDocument* const	theDocument =
+						m_parserLiaison.parseXMLStream(inputSource,
+													   xmlIdentifier);
+		assert(theDocument != 0);
+
+#if defined(XALAN_VQ_SPECIAL_TRACE)
+		QuantifyStopRecordingData();
+#endif
+		if(0 != m_diagnosticsPrintWriter)
+		{
+			displayDuration(
+				XALAN_STATIC_UCODE_STRING("Parse of ") + xmlIdentifier,
+				&xmlIdentifier);
+		}
+
+		m_xpathEnvSupport.setSourceDocument(xmlIdentifier, theDocument);
+
+		sourceTree = theDocument;
+	}
+
+	return sourceTree;
+}
+
+
+
+const XalanDOMString*
+XSLTEngineImpl::getNamespaceForPrefix(const XalanDOMString&		prefix) const
+{
+	return m_resultNamespacesStack.getNamespaceForPrefix(prefix);
+}
+
+
+
+const XalanDOMString&
+XSLTEngineImpl::getURI() const
+{
+	return s_emptyString;
+}
+
+
+
+XalanDocument*
+XSLTEngineImpl::parseXML(
+			const XalanDOMString&	urlString,
+			DocumentHandler*		docHandler,
+			XalanDocument*			docToRegister)
+{
+	
+	XalanDocument*	doc =
+			m_xpathEnvSupport.getSourceDocument(urlString);
+
+	if(doc == 0)
+	{
+		EntityResolver* const	theResolver = 
+			m_parserLiaison.getEntityResolver();
+
+		if (theResolver == 0)
+		{
+			const XSLTInputSource	inputSource(c_wstr(urlString));
+
+			doc = parseXML(inputSource, docHandler, docToRegister);
+		}
+		else
+		{
+			const XalanAutoPtr<InputSource>		resolverInputSource =
+				theResolver->resolveEntity(0, c_wstr(urlString));
+
+			if (resolverInputSource.get() != 0)
+			{
+				doc = parseXML(*resolverInputSource.get(), docHandler, docToRegister);
+			}
+			else
+			{
+				const XSLTInputSource	inputSource(c_wstr(urlString));
+
+				doc = parseXML(inputSource, docHandler, docToRegister);
+			}
+		}
+
+		if (doc != 0)
+		{
+			m_xpathEnvSupport.setSourceDocument(urlString, doc);
+		}
+	}
+
+	return doc;
+}
+
+
+
+XalanDocument*
+XSLTEngineImpl::parseXML(
+			const InputSource&	inputSource,
+			DocumentHandler*	docHandler,
+			XalanDocument*		docToRegister)
+{
+	if(0 != docHandler)
+	{
+		m_parserLiaison.parseXMLStream(inputSource, *docHandler);
+
+		return docToRegister;
+	}
+	else
+	{
+		return m_parserLiaison.parseXMLStream(inputSource);
+	}
+}
+
+
+
+Stylesheet*
+XSLTEngineImpl::getStylesheetFromPIURL(
+			const XalanDOMString&			xslURLString,
+			XalanNode&						fragBase,
+			const XalanDOMString&			xmlBaseIdent,
+			bool							isRoot,
+			StylesheetConstructionContext&	constructionContext)
+{
+	Stylesheet*				stylesheet = 0;
+
+	XalanDOMString			stringHolder;
+
+	XalanDOMString			localXSLURLString = trim(xslURLString);
+
+	const unsigned int		fragIndex = indexOf(localXSLURLString, XalanUnicode::charNumberSign);
+
+	const XalanDocument*	stylesheetDoc = 0;
+
+	if(fragIndex == 0)
+	{
+		diag("Locating stylesheet from fragment identifier...");
+
+		const XalanDOMString	fragID = substring(localXSLURLString, 1);
+
+		const XalanElement*		nsNode = 0;
+
+		const XalanNode::NodeType	theType = fragBase.getNodeType();
+
+		if (theType == XalanNode::DOCUMENT_NODE)
+		{
+			const XalanDocument&	doc =
+#if defined(XALAN_OLD_STYLE_CASTS)
+				(const XalanDocument&)fragBase;
+#else
+				static_cast<const XalanDocument&>(fragBase);
+#endif
+
+			nsNode = doc.getDocumentElement(); 
+		}
+		else if	(theType == XalanNode::ELEMENT_NODE)
+		{
+#if defined(XALAN_OLD_STYLE_CASTS)
+			nsNode = (const XalanElement*)&fragBase;
+#else
+			nsNode = static_cast<const XalanElement*>(&fragBase);
+#endif
+		}
+		else
+		{
+			XalanNode* const	node = fragBase.getParentNode();
+
+			if	(node->getNodeType() == XalanNode::ELEMENT_NODE) 
+			{
+#if defined(XALAN_OLD_STYLE_CASTS)
+				nsNode = (const XalanElement*)&fragBase;
+#else
+				nsNode = static_cast<XalanElement*>(node);
+#endif
+			}
+			else
+			{
+				error("Could not identify fragment: " + fragID);
+			}
+		}
+
+		// Try a bunch of really ugly stuff to find the fragment.
+		// What's the right way to do this?
+		XalanDOMString	ds(XALAN_STATIC_UCODE_STRING("id("));
+
+		ds += fragID;
+		ds += XALAN_STATIC_UCODE_STRING(")");
+
+		ElementPrefixResolverProxy		theProxy(nsNode, m_xpathEnvSupport, m_domSupport);
+
+		XPathExecutionContextDefault	theExecutionContext(m_xpathEnvSupport,
+															m_domSupport,
+															m_xobjectFactory,
+															&fragBase,
+															0,
+															&theProxy);
+
+		const XObjectPtr	xobj(evalXPathStr(ds, theExecutionContext));
+		assert(xobj.null() == false);
+
+		NodeRefList		nl(xobj->nodeset());
+
+		if(nl.getLength() == 0)
+		{
+			NodeRefList		theEmptyList;
+
+			ds = XALAN_STATIC_UCODE_STRING("//*[@id='");
+			ds += fragID;
+			ds += XALAN_STATIC_UCODE_STRING("']");
+
+			theExecutionContext.setContextNodeList(theEmptyList);
+
+			const XObjectPtr	xobj(evalXPathStr(ds, theExecutionContext));
+			assert(xobj.null() == false);
+
+			nl = xobj->nodeset();
+
+			if(nl.getLength() == 0)
+			{
+				ds = XALAN_STATIC_UCODE_STRING("//*[@name='");
+				ds += fragID;
+				ds += XALAN_STATIC_UCODE_STRING("']");
+
+				theExecutionContext.setContextNodeList(theEmptyList);
+
+				const XObjectPtr	xobj(evalXPathStr(ds, theExecutionContext));
+				assert(xobj.null() == false);
+
+				nl = xobj->nodeset();
+
+				if(nl.getLength() == 0)
+				{
+					// Well, hell, maybe it's an XPath...
+					theExecutionContext.setContextNodeList(theEmptyList);
+
+					const XObjectPtr	xobj(evalXPathStr(fragID, theExecutionContext));
+					assert(xobj.null() == false);
+
+					nl = xobj->nodeset();
+				}
+			}
+		}
+
+		if(nl.getLength() == 0)
+		{
+			error("Could not find fragment: " + fragID);
+		}
+
+		XalanNode* const	frag = nl.item(0);
+
+		if(XalanNode::ELEMENT_NODE == frag->getNodeType())
+		{
+			pushTime(frag);
+
+			XalanAutoPtr<Stylesheet>	theGuard;
+
+			if(isRoot)
+			{
+				StylesheetRoot* const	theLocalRoot =
+					constructionContext.create(stringHolder);
+
+				stylesheet = theLocalRoot;
+
+				m_stylesheetRoot = theLocalRoot;
+			}
+			else
+			{
+#if defined(XALAN_OLD_STYLE_CASTS)
+				stylesheet = constructionContext.create(*((StylesheetRoot*)m_stylesheetRoot), stringHolder);
+#else
+				stylesheet = constructionContext.create(*const_cast<StylesheetRoot*>(m_stylesheetRoot), stringHolder);
+#endif
+
+				theGuard.reset(stylesheet);
+			}
+
+			StylesheetHandler stylesheetProcessor(*stylesheet, constructionContext);
+
+			FormatterTreeWalker tw(stylesheetProcessor);
+
+			tw.traverse(frag, frag->getParentNode());
+
+			displayDuration(
+					XalanDOMString(XALAN_STATIC_UCODE_STRING("Setup of ")) +
+					localXSLURLString,
+					frag);
+
+			stylesheet->postConstruction(constructionContext);
+
+			theGuard.release();
+		}
+		else
+		{
+			stylesheetDoc = 0;
+			error("Node pointed to by fragment identifier was not an element: " + fragID);
+		}
+	}
+	else
+	{
+		diag(XalanDOMString(XALAN_STATIC_UCODE_STRING("========= Parsing and preparing ")) +
+				localXSLURLString +
+				XALAN_STATIC_UCODE_STRING(" =========="));
+		pushTime(&localXSLURLString);
+
+		XalanAutoPtr<Stylesheet>	theGuard;
+
+		const XalanDocument* const	theOwnerDocument =
+				fragBase.getNodeType() == XalanNode::DOCUMENT_NODE ?
+#if defined(XALAN_OLD_STYLE_CASTS)
+				(const XalanDocument*)&fragBase :
+#else
+				static_cast<const XalanDocument*>(&fragBase) :
+#endif
+				fragBase.getOwnerDocument();
+		assert(theOwnerDocument != 0);
+
+		if (length(xmlBaseIdent) == 0)
+		{
+			localXSLURLString =
+					URISupport::getURLStringFromString(
+						localXSLURLString,
+						m_xpathEnvSupport.findURIFromDoc(theOwnerDocument));
+		}
+		else
+		{
+			localXSLURLString =
+					URISupport::getURLStringFromString(
+						localXSLURLString,
+						xmlBaseIdent);
+		}
+
+		if(isRoot)
+		{
+			StylesheetRoot* const	theLocalRoot =
+					constructionContext.create(localXSLURLString);
+
+			stylesheet = theLocalRoot;
+
+			m_stylesheetRoot = theLocalRoot;
+		}
+		else
+		{
+#if defined(XALAN_OLD_STYLE_CASTS)
+			stylesheet = new Stylesheet(*(StylesheetRoot*)m_stylesheetRoot, localXSLURLString, constructionContext);
+#else
+			stylesheet = new Stylesheet(*const_cast<StylesheetRoot*>(m_stylesheetRoot), localXSLURLString, constructionContext);
+#endif
+
+			theGuard.reset(stylesheet);
+		}
+
+		StylesheetHandler stylesheetProcessor(*stylesheet, constructionContext);
+
+		typedef StylesheetConstructionContext::URLAutoPtrType	URLAutoPtrType;
+
+		URLAutoPtrType	xslURL(constructionContext.getURLFromString(localXSLURLString));
+
+		XSLTInputSource		inputSource(xslURL->getURLText());
+
+		m_parserLiaison.parseXMLStream(inputSource, stylesheetProcessor);
+
+		stylesheet->postConstruction(constructionContext);
+
+		theGuard.release();
+
+		displayDuration("Parsing and init of " + localXSLURLString, &localXSLURLString);
+	}
+
+	return stylesheet;
+}
+
+
+//==========================================================
+// SECTION: Stylesheet Tables
+//==========================================================
+
+
+double
+XSLTEngineImpl::getXSLTVerSupported()
+{
+	return s_XSLTVerSupported;
+}
+
+
+//==========================================================
+// SECTION: XSL directive handling functions
+//==========================================================  
+
+
+
+int
+XSLTEngineImpl::getXSLToken(const XalanNode&	node) const
+{
+	int 	tok = -2;
+
+	if(XalanNode::ELEMENT_NODE != node.getNodeType()) return tok;
+
+	const XalanDOMString& 	ns = node.getNamespaceURI();
+
+	if(equals(ns, s_XSLNameSpaceURL))
+	{
+		const XalanDOMString& 	localName =
+			DOMServices::getLocalNameOfNode(node);
+
+		const ElementKeysMapType::const_iterator		j =
+						s_elementKeys.find(localName);
+
+		if(j != s_elementKeys.end())
+		{
+			tok = (*j).second;
+		}
+	}
+	else if(equals(ns, s_XSLT4JNameSpaceURL))
+	{
+		const XalanDOMString&	localName =
+			DOMServices::getLocalNameOfNode(node);
+
+		const ElementKeysMapType::const_iterator		j =
+						s_XSLT4JElementKeys.find(localName);
+
+		if(j != s_XSLT4JElementKeys.end())
+		{
+			tok = (*j).second;
+		}
+	}
+
+	return tok;
+}
+
+
+
+void
+XSLTEngineImpl::outputToResultTree(
+			StylesheetExecutionContext&		executionContext,
+			const XObject&					value)
+{
+	const XObject::eObjectType	type = value.getType();
+
+	switch(type)
+	{
+	case XObject::eTypeBoolean:
+	case XObject::eTypeNumber:
+	case XObject::eTypeString:
+		{
+			const XalanDOMString&	s = value.str();
+
+			characters(toCharArray(s), 0, length(s));
+		}
+		break;				
+
+	case XObject::eTypeNodeSet:
+		{
+			const NodeRefListBase&	nl = value.nodeset();
+
+			const unsigned int		nChildren = nl.getLength();
+
+			for(unsigned int i = 0; i < nChildren; i++)
+			{
+				XalanNode*			pos = nl.item(i);
+				assert(pos != 0);
+
+				XalanNode* const	top = pos;
+
+				while(0 != pos)
+				{
+					flushPending();
+
+					XalanNode::NodeType		posNodeType = pos->getNodeType();
+
+					cloneToResultTree(*pos, posNodeType, false, false, true);
+
+					XalanNode*	nextNode = pos->getFirstChild();
+
+					while(0 == nextNode)
+					{
+						if(XalanNode::ELEMENT_NODE == posNodeType)
+						{
+							endElement(c_wstr(pos->getNodeName()));
+						}
+
+						if(top == pos)
+							break;
+
+						nextNode = pos->getNextSibling();
+
+						if(0 == nextNode)
+						{
+							pos = pos->getParentNode();
+							assert(pos != 0);
+
+							posNodeType = pos->getNodeType();
+
+							if(top == pos)
+							{
+								if(XalanNode::ELEMENT_NODE == posNodeType)
+								{
+									endElement(c_wstr(pos->getNodeName()));
+								}
+
+								nextNode = 0;
+								break;
+							}
+						}
+					}
+
+					pos = nextNode;
+
+					if (pos != 0)
+					{
+						posNodeType = pos->getNodeType();
+					}
+				}
+			}
+		}
+		break;
+		
+	case XObject::eTypeResultTreeFrag:
+		outputResultTreeFragment(executionContext, value);
+		break;
+
+	case XObject::eTypeNull:
+	case XObject::eTypeUnknown:
+	case XObject::eUnknown:
+	default:
+		assert(0);
+	}
+}
+
+
+
+const StylesheetRoot*
+XSLTEngineImpl::getStylesheetRoot() const
+{
+	return m_stylesheetRoot;
+}
+
+
+
+void
+XSLTEngineImpl::setStylesheetRoot(const StylesheetRoot*		theStylesheet)
+{
+	m_stylesheetRoot = theStylesheet;
+}
+
+
+
+void
+XSLTEngineImpl::setExecutionContext(StylesheetExecutionContext*		theExecutionContext)
+{
+	m_executionContext = theExecutionContext;
+}
+
+
+
+//==========================================================
+// SECTION: Diagnostic functions
+//==========================================================
+
+unsigned long
+XSLTEngineImpl::getTraceListeners() const
+{
+	return m_traceListeners.size();
+}
+
+
+
+void
+XSLTEngineImpl::addTraceListener(TraceListener* tl)
+{
+	if (tl != 0)
+	{
+		m_traceListeners.push_back(tl);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::removeTraceListener(TraceListener*	tl)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::remove;
+#endif
+
+	const TraceListenerVectorType::iterator		i =
+		remove(
+			m_traceListeners.begin(),
+			m_traceListeners.end(),
+			tl);
+
+	m_traceListeners.erase(i);
+}
+
+
+
+void
+XSLTEngineImpl::fireGenerateEvent(const GenerateEvent&	ge)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	for_each(
+		m_traceListeners.begin(),
+		m_traceListeners.end(),
+		TraceListener::TraceListenerGenerateFunctor(ge));
+}
+
+
+
+void
+XSLTEngineImpl::fireSelectEvent(const SelectionEvent&	se)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	for_each(
+		m_traceListeners.begin(),
+		m_traceListeners.end(),
+		TraceListener::TraceListenerSelectFunctor(se));
+}
+
+
+
+void
+XSLTEngineImpl::fireTraceEvent(const TracerEvent& te)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	for_each(
+		m_traceListeners.begin(),
+		m_traceListeners.end(),
+		TraceListener::TraceListenerTraceFunctor(te));
+}
+
+
+
+bool
+XSLTEngineImpl::getTraceSelects() const
+{
+	return m_traceSelects;
+}
+
+
+
+void
+XSLTEngineImpl::setTraceSelects(bool	b)
+{
+	m_traceSelects = b;
+}
+
+
+
+void
+XSLTEngineImpl::message(
+			const XalanDOMString&	msg,
+			const XalanNode*		sourceNode,
+			const XalanNode*		styleNode) const
+{
+	problem(msg, ProblemListener::eMESSAGE, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::message(
+			const XalanDOMString&		msg,
+			const XalanNode*			sourceNode,
+			const ElemTemplateElement*	styleNode) const
+{
+	problem(msg, ProblemListener::eMESSAGE, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::message(
+			const char*			msg,
+			const XalanNode*	sourceNode,
+			const XalanNode*	styleNode) const
+{
+	message(TranscodeFromLocalCodePage(msg), sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::problem(
+			const XalanDOMString&				msg, 
+			ProblemListener::eClassification	classification,
+			const XalanNode*					sourceNode,
+			const XalanNode*					styleNode) const
+{
+	const Locator* const	locator = getLocatorFromStack();
+
+	const XalanDOMChar*		id = 0;
+
+	XalanDOMString			uri;
+
+	int						lineNumber = -1;
+	int 					columnNumber = -1;
+
+	if (locator != 0)
+	{
+		id = locator->getPublicId();
+
+		if (id == 0)
+		{
+			id = locator->getSystemId();
+		}
+
+		if (id != 0)
+		{
+			uri = id;
+		}
+
+		lineNumber = locator->getLineNumber();
+		columnNumber = locator->getColumnNumber();
+	}
+
+	if (m_problemListener != 0)
+	{
+		m_problemListener->problem(
+					ProblemListener::eXSLPROCESSOR,
+					classification,
+					sourceNode,
+					styleNode,
+					msg,
+					id,
+					lineNumber,
+					columnNumber);
+	}
+
+	if (classification == ProblemListener::eERROR)
+	{
+		throw XSLTProcessorException(msg, uri, lineNumber, columnNumber);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::problem(
+			const XalanDOMString&				msg, 
+			ProblemListener::eClassification	classification,
+			const XalanNode*					sourceNode,
+			const ElemTemplateElement*			styleNode) const
+{
+	const XalanDOMChar*		id = 0;
+
+	XalanDOMString			uri;
+
+	int						lineNumber = -1;
+	int 					columnNumber = -1;
+
+	const Locator*			locator = getLocatorFromStack();
+
+	if (locator == 0)
+	{
+		locator = styleNode->getLocator();
+	}
+
+	if (locator != 0)
+	{
+		id = locator->getPublicId();
+
+		if (id == 0)
+		{
+			id = locator->getSystemId();
+		}
+
+		if (id != 0)
+		{
+			uri = id;
+		}
+
+		lineNumber = locator->getLineNumber();
+		columnNumber = locator->getColumnNumber();
+	}
+	else if (styleNode != 0)
+	{
+		lineNumber = styleNode->getLineNumber();
+		columnNumber = styleNode->getColumnNumber();
+
+		uri = styleNode->getURI();
+	}
+
+	if (m_problemListener != 0)
+	{
+		m_problemListener->problem(
+					ProblemListener::eXSLPROCESSOR,
+					classification,
+					styleNode,
+					sourceNode,
+					msg,
+					id,
+					lineNumber,
+					columnNumber);
+	}
+
+	if (classification == ProblemListener::eERROR)
+	{
+		throw XSLTProcessorException(msg, uri, lineNumber, columnNumber);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::warn(
+			const XalanDOMString&	msg,
+			const XalanNode*		sourceNode,
+			const XalanNode*		styleNode) const
+{
+	problem(msg, ProblemListener::eWARNING, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::warn(
+			const XalanDOMString&		msg,
+			const XalanNode*			sourceNode,
+			const ElemTemplateElement*	styleNode) const
+{
+	problem(msg, ProblemListener::eWARNING, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::warn(
+			const char*			msg,
+			const XalanNode*	sourceNode,
+			const XalanNode*	styleNode) const
+{
+	warn(TranscodeFromLocalCodePage(msg), sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::error(
+			const XalanDOMString&	msg,
+			const XalanNode*		sourceNode,
+			const XalanNode*		styleNode) const
+{
+	problem(msg, ProblemListener::eERROR, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::error(
+			const XalanDOMString&		msg,
+			const XalanNode*			sourceNode,
+			const ElemTemplateElement*	styleNode) const
+{
+	problem(msg, ProblemListener::eERROR, sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::error(
+			const char*			msg,
+			const XalanNode*	sourceNode,
+			const XalanNode*	styleNode) const
+{
+	error(TranscodeFromLocalCodePage(msg), sourceNode, styleNode);
+}
+
+
+
+void
+XSLTEngineImpl::pushTime(const void*	key)
+{
+	if(0 != key)
+	{
+		m_durationsTable[key] = clock();
+	}
+}
+
+
+
+clock_t
+XSLTEngineImpl::popDuration(const void*		key)
+{
+	clock_t 	clockTicksDuration = 0;
+
+	if(0 != key)
+	{
+		const DurationsTableMapType::iterator	i =
+				m_durationsTable.find(key);
+
+		if (i != m_durationsTable.end())
+		{
+			clockTicksDuration = clock() - (*i).second;
+
+			m_durationsTable.erase(i);
+		}
+	}
+
+	return clockTicksDuration;
+}
+
+
+
+void
+XSLTEngineImpl::displayDuration(
+			const XalanDOMString&	info,
+			const void*				key)
+{
+	if(0 != key)
+	{
+		const clock_t	theDuration = popDuration(key);
+
+		if(0 != m_diagnosticsPrintWriter)
+		{
+			const double	millis = (double(theDuration) / CLOCKS_PER_SEC) * 1000.0L;
+
+			XalanDOMString	msg(info);
+
+			msg += XALAN_STATIC_UCODE_STRING(" took ");
+			msg += DoubleToDOMString(millis);
+			msg += XALAN_STATIC_UCODE_STRING(" milliseconds");
+
+			m_diagnosticsPrintWriter->println(msg);
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::setDiagnosticsOutput(PrintWriter*	pw)
+{
+	m_diagnosticsPrintWriter = pw;
+
+	m_problemListener->setPrintWriter(pw);
+}
+
+
+
+void
+XSLTEngineImpl::diag(const XalanDOMString& 	s) const
+{
+	if (0 != m_diagnosticsPrintWriter)
+	{
+		m_diagnosticsPrintWriter->println(s);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::diag(const char*	s) const
+{
+	diag(TranscodeFromLocalCodePage(s));
+}
+
+
+
+void
+XSLTEngineImpl::setQuietConflictWarnings(bool	b)
+{
+	m_quietConflictWarnings = b;
+}
+
+
+
+void
+XSLTEngineImpl::setDocumentLocator(const Locator* const		/* locator */)
+{
+	// Do nothing for now
+}
+
+
+
+void
+XSLTEngineImpl::traceSelect(
+			const XalanElement& 	theTemplate,
+			const NodeRefListBase&	nl) const
+{
+	if (0 != m_diagnosticsPrintWriter)
+	{
+		XalanDOMString	msg = theTemplate.getNodeName() + XalanDOMString(XALAN_STATIC_UCODE_STRING(": "));
+
+		XalanAttr*		attr = theTemplate.getAttributeNode(Constants::ATTRNAME_SELECT);
+
+		if(0 != attr)
+		{
+			msg += attr->getValue();
+			msg += XALAN_STATIC_UCODE_STRING(", ");
+			msg += LongToDOMString(nl.getLength());
+			msg += XALAN_STATIC_UCODE_STRING(" selected");
+		}
+		else
+		{
+			msg += XALAN_STATIC_UCODE_STRING("*|text(), (default select), ");
+			msg += LongToDOMString(nl.getLength());
+			msg += XALAN_STATIC_UCODE_STRING(" selected");
+		}
+
+		attr = theTemplate.getAttributeNode(Constants::ATTRNAME_MODE);
+
+		if(0 != attr)
+		{
+			msg += XalanDOMString(XALAN_STATIC_UCODE_STRING(", mode = ")) + attr->getValue();
+		}
+
+		m_diagnosticsPrintWriter->println(msg);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::startDocument()
+{
+	assert(getFormatterListener() != 0);
+	assert(m_executionContext != 0);
+
+	if (getHasPendingStartDocument() == false)
+	{
+		m_resultNamespacesStack.pushContext();
+
+		setHasPendingStartDocument(true);
+
+		setMustFlushPendingStartDocument(false);
+	}
+	else if (getMustFlushPendingStartDocument() == true)
+	{
+		getFormatterListener()->startDocument();
+
+		if(getTraceListeners() > 0)
+		{
+			const GenerateEvent		ge(GenerateEvent::EVENTTYPE_STARTDOCUMENT);
+
+			fireGenerateEvent(ge);
+		}
+
+		// Reset this, but leave getMustFlushPendingStartDocument() alone,
+		// since it will still be needed.
+		setHasPendingStartDocument(false);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::endDocument()
+{
+	assert(getFormatterListener() != 0);
+	assert(m_executionContext != 0);
+
+	setMustFlushPendingStartDocument(true);
+
+	flushPending();
+
+	getFormatterListener()->endDocument();
+
+	if(getTraceListeners() > 0)
+	{
+		const GenerateEvent		ge(GenerateEvent::EVENTTYPE_ENDDOCUMENT);
+
+		fireGenerateEvent(ge);
+	}
+
+	m_resultNamespacesStack.popContext();
+
+	assert(m_resultNamespacesStack.size() == 0);
+}
+
+
+
+void
+XSLTEngineImpl::addResultNamespaceDecl(
+			const XalanDOMString&	prefix, 
+	        const XalanDOMString&	namespaceVal)
+{
+	m_resultNamespacesStack.addDeclaration(prefix, namespaceVal);
+}
+
+
+
+void
+XSLTEngineImpl::addResultAttribute(
+			AttributeListImpl&	attList,
+			const XalanDOMString&	aname,
+			const XalanDOMString&	value)
+{
+	bool	fExcludeAttribute = false;
+
+	if (equals(aname, DOMServices::s_XMLNamespace)) 
+	{
+		// OK, we're adding a default namespace declaration.  So see if the length
+		// of the namespace is 0.  If it's not, go ahead and add the declaration.
+		// If it's not, it means we're "turning off" the previous default
+		// declaration.
+
+		const XalanDOMString* const		currentDefaultNamespace =
+					getNamespaceForPrefix(s_emptyString);
+
+		// Note that we use an empty string for the prefix, instead of "xmlns", since the
+		// prefix really is "".
+		if (length(value) != 0)
+		{
+			if (currentDefaultNamespace != 0 &&
+				equals(*currentDefaultNamespace, value) == true)
+			{
+				fExcludeAttribute = true;
+			}
+			else
+			{
+				addResultNamespaceDecl(s_emptyString, value);
+			}
+		}
+		else
+		{
+			// OK, we're turning of the previous default namespace declaration.
+			// Check to see if there is one, and if there isn't, don't add
+			// the namespace declaration _and_ don't add the attribute.
+			if (currentDefaultNamespace != 0 && length(*currentDefaultNamespace) != 0)
+			{
+				addResultNamespaceDecl(s_emptyString, value);
+			}
+			else
+			{
+				fExcludeAttribute = true;
+			}
+		}
+	}
+	else if (startsWith(aname, DOMServices::s_XMLNamespaceWithSeparator) == true)
+	{
+		assert(m_executionContext != 0);
+
+		StylesheetExecutionContext::GetAndReleaseCachedString	prefixGuard(*m_executionContext);
+
+		XalanDOMString&		prefix = prefixGuard.get();
+
+		prefix = substring(aname, DOMServices::s_XMLNamespaceWithSeparatorLength);
+
+		addResultNamespaceDecl(prefix, value);
+	}
+
+	if (fExcludeAttribute == false)
+	{
+		attList.addAttribute(
+			c_wstr(aname),
+			c_wstr(Constants::ATTRTYPE_CDATA),
+			c_wstr(value));
+	}
+}
+
+
+
+bool
+XSLTEngineImpl::pendingAttributesHasDefaultNS() const
+{
+	const AttributeListImpl&	thePendingAttributes =
+		getPendingAttributes();
+
+	const unsigned int	n = thePendingAttributes.getLength();
+
+	for(unsigned int i = 0; i < n; i++)
+	{
+		if(equals(thePendingAttributes.getName(i),
+				  DOMServices::s_XMLNamespace) == true)
+		{
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+
+void
+XSLTEngineImpl::flushPending()
+{
+	if(getHasPendingStartDocument() == true && 0 != length(getPendingElementName()))
+	{
+		assert(getFormatterListener() != 0);
+		assert(m_executionContext != 0);
+
+		if (m_stylesheetRoot->isOutputMethodSet() == false)
+		{
+			if (equalsIgnoreCaseASCII(getPendingElementName(),
+								 Constants::ELEMNAME_HTML_STRING) == true &&
+				pendingAttributesHasDefaultNS() == false)
+			{
+				if (getFormatterListener()->getOutputFormat() == FormatterListener::OUTPUT_METHOD_XML)
+				{
+					// Yuck!!! Ugly hack to switch to HTML on-the-fly.
+					FormatterToXML* const	theFormatter =
+#if defined(XALAN_OLD_STYLE_CASTS)
+						(FormatterToXML*)getFormatterListener();
+#else
+						static_cast<FormatterToXML*>(getFormatterListener());
+#endif
+
+					setFormatterListenerImpl(
+						m_executionContext->createFormatterToHTML(
+							*theFormatter->getWriter(),
+							theFormatter->getEncoding(),
+							theFormatter->getMediaType(),
+							theFormatter->getDoctypeSystem(),
+							theFormatter->getDoctypePublic(),
+							true,	// indent
+							theFormatter->getIndent() > 0 ? theFormatter->getIndent() :
+											StylesheetExecutionContext::eDefaultHTMLIndentAmount));
+				}
+			}
+		}
+	}
+
+	XalanDOMString&		thePendingElementName = getPendingElementNameImpl();
+
+	if(getHasPendingStartDocument() == true && getMustFlushPendingStartDocument() == true)
+	{
+		startDocument();
+	}
+
+	if(0 != length(thePendingElementName) && getMustFlushPendingStartDocument() == true)
+	{
+		assert(getFormatterListener() != 0);
+		assert(m_executionContext != 0);
+
+		m_cdataStack.push_back(isCDataResultElem(thePendingElementName) ? true : false);
+
+		AttributeListImpl&	thePendingAttributes =
+				getPendingAttributesImpl();
+
+		getFormatterListener()->startElement(c_wstr(thePendingElementName), thePendingAttributes);
+
+		if(getTraceListeners() > 0)
+		{
+			const GenerateEvent		ge(
+				GenerateEvent::EVENTTYPE_STARTELEMENT,
+				thePendingElementName,
+				&thePendingAttributes);
+
+			fireGenerateEvent(ge);
+		}
+
+		thePendingAttributes.clear();
+
+		clear(thePendingElementName);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::startElement(const XMLCh* const	name)
+{
+	assert(getFormatterListener() != 0);
+	assert(name != 0);
+
+	flushPending();
+
+	m_resultNamespacesStack.pushContext();
+
+	setPendingElementName(name);
+
+	setMustFlushPendingStartDocument(true);
+}
+
+
+
+void
+XSLTEngineImpl::startElement(
+			const XMLCh* const	name,
+			AttributeList&		atts)
+{
+	assert(getFormatterListener() != 0);
+	assert(name != 0);
+
+	flushPending();
+
+	const unsigned int	nAtts = atts.getLength();
+
+	assert(m_outputContextStack.size() > 0);
+
+	AttributeListImpl&	thePendingAttributes =
+		getPendingAttributesImpl();
+
+	thePendingAttributes.clear();
+
+	for(unsigned int i = 0; i < nAtts; i++)
+	{
+		thePendingAttributes.addAttribute(
+			atts.getName(i),
+			atts.getType(i),
+			atts.getValue(i));
+	}
+
+	m_resultNamespacesStack.pushContext();
+
+	setPendingElementName(name);
+}
+
+
+
+void
+XSLTEngineImpl::endElement(const XMLCh* const 	name)
+{
+	assert(getFormatterListener() != 0);
+	assert(name != 0);
+
+	flushPending();
+
+	getFormatterListener()->endElement(name);
+
+	if(getTraceListeners() > 0)
+	{
+		const GenerateEvent		ge(GenerateEvent::EVENTTYPE_ENDELEMENT, name);
+
+		fireGenerateEvent(ge);
+	}
+
+	m_resultNamespacesStack.popContext();
+
+	if(m_stylesheetRoot->hasCDATASectionElements() == true)
+	{
+		m_cdataStack.pop_back();
+	}
+}
+
+
+
+void
+XSLTEngineImpl::characters(
+			const XMLCh* const	ch,
+			const unsigned int 	length)
+{
+	characters(ch,
+			   0,
+			   length);
+}
+
+
+
+void
+XSLTEngineImpl::characters(
+			const XMLCh* const	ch,
+			const unsigned int	start,
+			const unsigned int 	length)
+{
+	assert(getFormatterListener() != 0);
+	assert(ch != 0);
+
+	doFlushPending();
+
+	if(generateCDATASection() == true)
+	{
+		getFormatterListener()->cdata(ch + start, length);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(ch, start, length, true);
+		}
+	}
+	else
+	{
+		getFormatterListener()->characters(ch + start, length);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(ch, start, length, false);
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::characters(const XalanNode&		node)
+{
+	assert(getFormatterListener() != 0);
+
+	doFlushPending();
+
+	if(generateCDATASection() == true)
+	{
+		DOMServices::getNodeData(node, *getFormatterListener(), &FormatterListener::cdata);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(node, true);
+		}
+	}
+	else
+	{
+		DOMServices::getNodeData(node, *getFormatterListener(), &FormatterListener::characters);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(node, false);
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::characters(const XObjectPtr&	xobject)
+{
+	assert(getFormatterListener() != 0);
+	assert(xobject.null() == false);
+
+	doFlushPending();
+
+	if(generateCDATASection() == true)
+	{
+		xobject->str(*getFormatterListener(), &FormatterListener::cdata);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(xobject, true);
+		}
+	}
+	else
+	{
+		xobject->str(*getFormatterListener(), &FormatterListener::characters);
+
+		if(getTraceListeners() > 0)
+		{
+			fireCharacterGenerateEvent(xobject, false);
+		}
+	}
+}
+
+
+
+void 
+XSLTEngineImpl::charactersRaw(
+			const XMLCh* const	ch,
+			const unsigned int	start,
+			const unsigned int	length)
+{
+	assert(ch != 0);
+
+	doFlushPending();
+
+	getFormatterListener()->charactersRaw(ch, length);
+
+	if(getTraceListeners() > 0)
+	{
+		fireCharacterGenerateEvent(ch, start, length, false);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::charactersRaw(const XalanNode&	node)
+{
+	doFlushPending();
+
+	DOMServices::getNodeData(node, *getFormatterListener(), &FormatterListener::charactersRaw);
+
+	if(getTraceListeners() > 0)
+	{
+		fireCharacterGenerateEvent(node, false);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::charactersRaw(const XObjectPtr&		xobject)
+{
+	doFlushPending();
+
+	xobject->str(*getFormatterListener(), &FormatterListener::charactersRaw);
+
+	if(getTraceListeners() > 0)
+	{
+		fireCharacterGenerateEvent(xobject, false);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::resetDocument()
+{
+	assert(getFormatterListener() != 0);
+
+	flushPending();
+	
+	getFormatterListener()->resetDocument();
+}
+
+
+
+void
+XSLTEngineImpl::ignorableWhitespace(
+			const XMLCh* const	ch,
+			const unsigned int 	length)
+{
+	assert(getFormatterListener() != 0);
+	assert(ch != 0);
+
+	doFlushPending();
+
+	getFormatterListener()->ignorableWhitespace(ch, length);
+
+	if(getTraceListeners() > 0)
+	{
+		GenerateEvent ge(GenerateEvent::EVENTTYPE_IGNORABLEWHITESPACE,
+					ch, 0, length);
+
+		fireGenerateEvent(ge);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::processingInstruction(
+			const XMLCh* const	target,
+			const XMLCh* const	data)
+{
+	assert(getFormatterListener() != 0);
+	assert(target != 0);
+	assert(data != 0);
+
+	doFlushPending();
+
+	getFormatterListener()->processingInstruction(target, data);
+
+	if(getTraceListeners() > 0)
+	{
+		GenerateEvent ge(
+				GenerateEvent::EVENTTYPE_PI,
+                target,
+				data);
+
+		fireGenerateEvent(ge);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::comment(const XMLCh* const	data)
+{
+	assert(getFormatterListener() != 0);
+	assert(data != 0);
+
+	doFlushPending();
+
+	getFormatterListener()->comment(data);
+
+	if(getTraceListeners() > 0)
+	{
+		GenerateEvent ge(GenerateEvent::EVENTTYPE_COMMENT,
+                                          data);
+		fireGenerateEvent(ge);
+	}
+}
+
+
+void
+XSLTEngineImpl::entityReference(const XMLCh* const	name)
+{
+	assert(getFormatterListener() != 0);
+	assert(name != 0);
+
+	doFlushPending();
+
+	getFormatterListener()->entityReference(name);
+
+	if(getTraceListeners() > 0)
+	{
+		GenerateEvent ge(GenerateEvent::EVENTTYPE_ENTITYREF,
+                                          name);
+
+		fireGenerateEvent(ge);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::cdata(
+			const XMLCh* const	ch,
+			const unsigned int 	start,
+			const unsigned int 	length)
+{
+	assert(getFormatterListener() != 0);
+	assert(ch != 0);
+
+	setMustFlushPendingStartDocument(true);
+
+	flushPending();
+
+	if(m_stylesheetRoot->hasCDATASectionElements() == true &&
+	   0 != m_cdataStack.size())
+	{
+		getFormatterListener()->cdata(ch, length);
+
+		if(getTraceListeners() > 0)
+		{
+			GenerateEvent ge(GenerateEvent::EVENTTYPE_CDATA, ch, start,
+					length);
+
+			fireGenerateEvent(ge);
+		}
+	}
+	else
+	{
+		getFormatterListener()->characters(ch, length);
+
+		if(getTraceListeners() > 0)
+		{
+			GenerateEvent ge(GenerateEvent::EVENTTYPE_CHARACTERS, ch,
+					start, length);
+
+			fireGenerateEvent(ge);
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::cloneToResultTree(
+			XalanNode&				node,
+			XalanNode::NodeType		nodeType,
+			bool					isLiteral,
+			bool					overrideStrip,
+			bool					shouldCloneAttributes)
+{
+	assert(nodeType == node.getNodeType());
+
+	switch(nodeType)
+	{
+	case XalanNode::TEXT_NODE:
+		{
+			bool	stripWhiteSpace = false;
+
+			// If stripWhiteSpace is false, then take this as an override and 
+			// just preserve the space, otherwise use the XSL whitespace rules.
+			if(!overrideStrip)
+			{
+				stripWhiteSpace = isLiteral ? true : false;
+			  // was: stripWhiteSpace = isLiteral ? true : shouldStripSourceNode(node);
+			}
+
+			const XalanText& 	tx =
+#if defined(XALAN_OLD_STYLE_CASTS)
+				(const XalanText&)node;
+#else
+				static_cast<const XalanText&>(node);
+#endif
+
+			const bool	isIgnorableWhitespace = tx.isIgnorableWhitespace();
+
+			if(stripWhiteSpace == false || isIgnorableWhitespace == false)
+			{
+				assert(tx.getParentNode() == 0 ||
+					   tx.getParentNode()->getNodeType() != XalanNode::DOCUMENT_NODE);
+
+				const XalanDOMString&	data = tx.getData();
+
+				if(0 != length(data))
+				{
+					if(isIgnorableWhitespace == true)
+					{
+						ignorableWhitespace(toCharArray(data), length(data));
+					}
+					else
+					{
+						characters(toCharArray(data), 0, length(data));
+					}
+				}
+			}			
+		}
+		break;
+
+	case XalanNode::ELEMENT_NODE:
+		startElement(c_wstr(node.getNodeName()));
+
+		if(shouldCloneAttributes == true)
+		{
+			copyAttributesToAttList(
+									m_stylesheetRoot,
+									node,
+									getPendingAttributesImpl());
+
+			copyNamespaceAttributes(node);
+		}
+		break;
+
+	case XalanNode::CDATA_SECTION_NODE:
+		{
+			const XalanDOMString& 	data = node.getNodeValue();
+
+			cdata(toCharArray(data), 0, length(data));
+		}
+		break;
+
+	case XalanNode::ATTRIBUTE_NODE:
+		addResultAttribute(
+				getPendingAttributesImpl(),
+#if defined(XALAN_OLD_STYLE_CASTS)
+				DOMServices::getNameOfNode((const XalanAttr&)node),
+#else
+				DOMServices::getNameOfNode(static_cast<const XalanAttr&>(node)),
+#endif
+				node.getNodeValue());
+		break;
+
+	case XalanNode::COMMENT_NODE:
+		comment(c_wstr(node.getNodeValue()));
+		break;
+
+	case XalanNode::DOCUMENT_FRAGMENT_NODE:
+		error("No clone of a document fragment!");
+		break;
+	
+	case XalanNode::ENTITY_REFERENCE_NODE:
+		entityReference(c_wstr(node.getNodeName()));
+		break;
+
+	case XalanNode::PROCESSING_INSTRUCTION_NODE:
+		processingInstruction(
+				c_wstr(node.getNodeName()),
+				c_wstr(node.getNodeValue()));
+		break;
+
+	// Can't really do this, but we won't throw an error so that copy-of will
+	// work
+	case XalanNode::DOCUMENT_NODE:
+	case XalanNode::DOCUMENT_TYPE_NODE:
+	break;
+
+	default:
+		error("Cannot create item in result tree: " + node.getNodeName());
+	break;
+
+	}
+}
+
+
+
+void
+XSLTEngineImpl::outputResultTreeFragment(
+			StylesheetExecutionContext&		executionContext,
+			const XObject&					theTree)
+{
+	const ResultTreeFragBase&	docFrag = theTree.rtree(executionContext);
+
+	const XalanNodeList* const	nl = docFrag.getChildNodes();
+	assert(nl != 0);
+
+	const unsigned int			nChildren = nl->getLength();
+
+	for(unsigned int i = 0; i < nChildren; i++)
+	{
+		XalanNode*				pos = nl->item(i);
+		assert(pos != 0);
+
+		XalanNode::NodeType		posNodeType = pos->getNodeType();
+
+		XalanNode* const		top = pos;
+
+		while(0 != pos)
+		{
+			flushPending();
+
+			cloneToResultTree(*pos, posNodeType, false, false, true);
+
+			XalanNode*	nextNode = pos->getFirstChild();
+
+			while(0 == nextNode)
+			{
+				if(XalanNode::ELEMENT_NODE == posNodeType)
+				{
+					endElement(c_wstr(pos->getNodeName()));
+				}
+
+				if(top == pos)
+					break;
+
+				nextNode = pos->getNextSibling();
+
+				if(0 == nextNode)
+				{
+					pos = pos->getParentNode();
+
+					if(0 == pos)
+					{
+						nextNode = 0;
+
+						break;
+					}
+					else
+					{
+						assert(0 != pos);
+
+						posNodeType = pos->getNodeType();
+
+						if(top == pos)
+						{
+							if(XalanNode::ELEMENT_NODE == posNodeType)
+							{
+								endElement(c_wstr(pos->getNodeName()));
+							}
+
+							nextNode = 0;
+
+							break;
+						}
+					}
+				}
+			}
+
+			pos = nextNode;
+
+			if (pos != 0)
+			{
+				posNodeType = pos->getNodeType();
+			}
+		}
+	}
+}
+
+
+
+bool
+XSLTEngineImpl::isCDataResultElem(const XalanDOMString&		elementName) const
+{
+	assert(m_executionContext != 0);
+
+	if(m_stylesheetRoot->hasCDATASectionElements() == false)
+	{
+		return false;
+	}
+	else
+	{
+		bool	fResult = false;
+
+		const unsigned int	indexOfNSSep = indexOf(elementName, XalanUnicode::charColon);
+
+		if(indexOfNSSep == length(elementName))
+		{
+			fResult = m_stylesheetRoot->isCDATASectionElementName(XalanQNameByReference(s_emptyString, elementName));
+		}
+		else
+		{
+			typedef StylesheetExecutionContext::GetAndReleaseCachedString	GetAndReleaseCachedString;
+
+			GetAndReleaseCachedString	elemLocalNameGuard(*m_executionContext);
+			GetAndReleaseCachedString	prefixGuard(*m_executionContext);
+
+			XalanDOMString&		elemLocalName = elemLocalNameGuard.get();
+			XalanDOMString&		prefix = prefixGuard.get();
+
+			substring(elementName, prefix, 0, indexOfNSSep);
+			substring(elementName, elemLocalName, indexOfNSSep + 1);
+
+			if(equals(prefix, DOMServices::s_XMLString))
+			{
+				fResult =
+					m_stylesheetRoot->isCDATASectionElementName(XalanQNameByReference(DOMServices::s_XMLNamespaceURI, elementName));
+			}
+			else
+			{
+				const XalanDOMString* const		elemNS =
+					getResultNamespaceForPrefix(prefix);
+
+				if(elemNS == 0)
+				{
+					error("Prefix must resolve to a namespace: " + prefix);
+				}
+				else
+				{
+					fResult =
+						m_stylesheetRoot->isCDATASectionElementName(XalanQNameByReference(*elemNS, elementName));
+				}
+			}
+		}
+
+		return fResult;
+	}
+}
+	
+
+
+const XalanDOMString*
+XSLTEngineImpl::getResultNamespaceForPrefix(const XalanDOMString&	prefix) const
+{
+	return m_resultNamespacesStack.getNamespaceForPrefix(prefix);
+}
+  
+
+
+const XalanDOMString*
+XSLTEngineImpl::getResultPrefixForNamespace(const XalanDOMString&	theNamespace) const
+{
+	return m_resultNamespacesStack.getPrefixForNamespace(theNamespace);
+}
+
+
+
+inline bool
+isPrefixUsed(
+			const XalanDOMString&	thePrefix,
+			unsigned int			thePrefixLength,
+			const XalanDOMChar*		theName,
+			unsigned int			theNameLength)
+{
+	assert(thePrefixLength != 0);
+
+	// The name must be greater than the length of the prefix + 1, since
+	// there must be a ':' to separate the prefix from the local part...
+	if (theNameLength <= thePrefixLength + 1)
+	{
+		return false;
+	}
+	else
+	{
+		assert(theName != 0);
+
+		const unsigned int	theIndex = indexOf(
+			theName,
+			XalanUnicode::charColon);
+
+		// OK, if the index of the ':' is the same as the length of the prefix,
+		// and theElementName starts with thePrefix, then the prefix is in use.
+		if (theIndex == thePrefixLength &&
+			startsWith(theName, thePrefix) == true)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+}
+
+
+
+inline bool
+isPrefixUsed(
+			const XalanDOMString&	thePrefix,
+			unsigned int			thePrefixLength,
+			const XalanDOMString&	theName)
+{
+	return isPrefixUsed(thePrefix, thePrefixLength, c_wstr(theName), length(theName));
+}
+
+
+
+inline bool
+isPrefixUsedOrDeclared(
+			const XalanDOMString&	thePrefix,
+			unsigned int			thePrefixLength,
+			const XalanDOMChar*		theName,
+			unsigned int			theNameLength)
+{
+	if (isPrefixUsed(thePrefix, thePrefixLength, theName, theNameLength) == true)
+	{
+		return true;
+	}
+	else
+	{
+		const unsigned int	theDeclarationLength =
+			thePrefixLength + DOMServices::s_XMLNamespaceWithSeparatorLength;
+
+		// If this is a namespace declaration for this prefix, then all of
+		// these conditions must be true...
+		if (theDeclarationLength == theNameLength &&
+			startsWith(theName, DOMServices::s_XMLNamespaceWithSeparator) == true &&
+			endsWith(theName, c_wstr(thePrefix)) == true)
+		{
+			return true;
+		}
+		else
+		{
+			return false;
+		}
+	}
+}
+
+
+
+inline bool
+isPendingAttributePrefix(
+			const AttributeList&		thePendingAttributes,
+			const XalanDOMString&		thePrefix,
+			unsigned int				thePrefixLength)
+{
+	const unsigned int	thePendingAttributesCount =
+				thePendingAttributes.getLength();
+
+	if (thePendingAttributesCount == 0)
+	{
+		// No attributes, no problem...
+		return false;
+	}
+	else
+	{
+		bool	fResult = false;
+
+		// Check each attribute...
+		for (unsigned int i = 0; i < thePendingAttributesCount; ++i)
+		{
+			const XalanDOMChar* const	thePendingAttributeName =
+							thePendingAttributes.getName(i);
+			assert(thePendingAttributeName != 0);
+
+			if (isPrefixUsedOrDeclared(
+					thePrefix,
+					thePrefixLength,
+					thePendingAttributeName,
+					length(thePendingAttributeName)) == true)
+			{
+				fResult = true;
+
+				break;
+			}
+		}
+
+		return fResult;
+	}
+}
+
+
+
+bool
+XSLTEngineImpl::isPendingResultPrefix(const XalanDOMString&		thePrefix) const
+{
+	const unsigned int	thePrefixLength = length(thePrefix);
+	assert(thePrefixLength > 0);
+
+	// The element name must be greater than the length of the prefix + 1, since
+	// there must be a ':' to separate the prefix from the local part...
+	if (isPrefixUsed(thePrefix, thePrefixLength, getPendingElementName()) == true)
+	{
+		return true;
+	}
+	else
+	{
+		// The element is not using the prefix, so check the
+		// pending attributes...
+		return isPendingAttributePrefix(
+						getPendingAttributes(),
+						thePrefix,
+						thePrefixLength);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::addResultNamespace(
+			const XalanNode&	theNode,
+			AttributeListImpl&	thePendingAttributes,
+			bool				fOnlyIfPrefixNotPresent)
+{
+	assert(theNode.getNodeType() == XalanNode::ATTRIBUTE_NODE);
+
+	const XalanDOMString& 	aname = theNode.getNodeName();
+
+	const bool	isPrefix = startsWith(aname, DOMServices::s_XMLNamespaceWithSeparator);
+
+	const XalanDOMString 	prefix = isPrefix == true ?
+			substring(aname, DOMServices::s_XMLNamespaceWithSeparatorLength) : XalanDOMString();
+
+	if (equals(aname, DOMServices::s_XMLNamespace) || isPrefix) 
+	{
+		if (fOnlyIfPrefixNotPresent == true)
+		{
+			if (m_resultNamespacesStack.prefixIsPresentLocal(prefix) == false)
+			{
+				const XalanDOMString* const 	desturi = getResultNamespaceForPrefix(prefix);
+				const XalanDOMString&			srcURI = theNode.getNodeValue();
+
+				if(desturi == 0 || equals(srcURI, *desturi) == false)
+				{
+					addResultAttribute(thePendingAttributes, aname, srcURI);
+				}
+			}
+		}
+		else
+		{
+			const XalanDOMString* const 	desturi = getResultNamespaceForPrefix(prefix);
+			const XalanDOMString&			srcURI = theNode.getNodeValue();
+
+			if(desturi == 0 || equals(srcURI, *desturi) == false)
+			{
+				addResultAttribute(thePendingAttributes, aname, srcURI);
+			}
+		}
+	}
+}
+
+
+
+void
+XSLTEngineImpl::copyNamespaceAttributes(const XalanNode&	src) 
+{
+	const XalanNode*	parent = &src;
+
+	while (parent != 0 &&
+		   parent->getNodeType() == XalanNode::ELEMENT_NODE) 
+	{
+		const XalanNamedNodeMap* const	nnm =
+				parent->getAttributes();
+		assert(nnm != 0);
+
+		const unsigned int	nAttrs = nnm->getLength();
+
+		assert(m_outputContextStack.size() > 0);
+
+		AttributeListImpl&	thePendingAttributes =
+				getPendingAttributesImpl();
+
+		for (unsigned int i = 0;  i < nAttrs; i++) 
+		{
+			const XalanNode* const	attr = nnm->item(i);
+			assert(attr != 0);
+
+			addResultNamespace(*attr, thePendingAttributes, true);
+		}
+
+		parent = parent->getParentNode();
+	}
+}
+
+
+
+const XObjectPtr
+XSLTEngineImpl::evalXPathStr(
+			const XalanDOMString&	str,
+			XPathExecutionContext&	executionContext)
+{
+	assert(executionContext.getPrefixResolver() != 0);
+
+	XPath* const	theXPath = m_xpathFactory.create();
+
+	XPathGuard	theGuard(m_xpathFactory,
+						 theXPath);
+
+    m_xpathProcessor->initXPath(*theXPath,
+								str,
+								*executionContext.getPrefixResolver(),
+								getLocatorFromStack());
+
+    return theXPath->execute(executionContext.getCurrentNode(),
+							 *executionContext.getPrefixResolver(),
+							 executionContext);
+}
+
+
+
+const XObjectPtr
+XSLTEngineImpl::evalXPathStr(
+			const XalanDOMString&	str,
+			XalanNode*				contextNode,
+			const PrefixResolver&	prefixResolver,
+			XPathExecutionContext&	executionContext)
+{
+	XPath* const	theXPath = m_xpathFactory.create();
+
+	XPathGuard	theGuard(m_xpathFactory,
+						 theXPath);
+
+    m_xpathProcessor->initXPath(*theXPath,
+								str,
+								prefixResolver,
+								getLocatorFromStack());
+
+    return theXPath->execute(contextNode, prefixResolver, executionContext);
+}
+
+
+
+const XObjectPtr
+XSLTEngineImpl::evalXPathStr(
+			const XalanDOMString&	str,
+			XalanNode*				contextNode,
+			const XalanElement&		prefixResolver,
+			XPathExecutionContext&	executionContext)
+{
+	ElementPrefixResolverProxy	theProxy(&prefixResolver,
+										 m_xpathEnvSupport,
+										 m_domSupport);
+
+	return evalXPathStr(str, contextNode, theProxy, executionContext);
+}
+
+
+
+
+/**
+ * Create and initialize an xpath and return it.
+ */
+const XPath*
+XSLTEngineImpl::createMatchPattern(
+			const XalanDOMString&	str,
+			const PrefixResolver&	resolver)
+{
+	XPath* const	xpath = m_xpathFactory.create();
+
+	m_xpathProcessor->initMatchPattern(*xpath, str, resolver, getLocatorFromStack());
+
+	return xpath;
+}
+
+
+
+void
+XSLTEngineImpl::returnXPath(const XPath*	xpath)
+{
+	m_xpathFactory.returnObject(xpath);
+}
+
+
+
+inline void
+XSLTEngineImpl::copyAttributeToTarget(
+			const XalanDOMString&	attrName,
+			const XalanDOMString&	attrValue,
+			AttributeListImpl&		attrList)
+{
+	// TODO: Find out about empty attribute template expression handling.
+	if(0 != length(attrValue))
+	{
+		addResultAttribute(attrList, attrName, attrValue);
+	}
+}
+
+
+
+void
+XSLTEngineImpl::copyAttributesToAttList(
+			const Stylesheet* 	stylesheetTree,
+			const XalanNode& 	node,
+			AttributeListImpl&	attList)
+{
+	assert(m_stylesheetRoot != 0);
+	assert(stylesheetTree != 0);
+
+	const XalanNamedNodeMap* const	attributes =
+		node.getAttributes();
+
+	if (attributes != 0)
+	{
+		const unsigned int	nAttributes = attributes->getLength();
+
+		for(unsigned int i = 0; i < nAttributes; ++i)  
+		{	
+			const XalanNode* const 	attr = attributes->item(i);
+			assert(attr != 0);
+
+			copyAttributeToTarget(
+				attr->getNodeName(),
+				attr->getNodeValue(),
+				attList);
+		}
+	}
+}
+
+
+
+bool
+XSLTEngineImpl::shouldStripSourceNode(
+			XPathExecutionContext&	executionContext,
+			const XalanNode&		textNode) const
+{
+	if (m_stylesheetRoot == 0)
+	{
+		return false;
+	}
+	else
+	{
+		bool	strip = false; // return value
+
+		if((m_stylesheetRoot->getWhitespacePreservingElements().size() > 0 ||
+			m_stylesheetRoot->getWhitespaceStrippingElements().size() > 0))
+		{
+			const XalanNode::NodeType	type = textNode.getNodeType();
+
+			if(XalanNode::TEXT_NODE == type || XalanNode::CDATA_SECTION_NODE == type)
+			{
+				const XalanText& 	theTextNode =
+#if defined(XALAN_OLD_STYLE_CASTS)
+						(const XalanText&)textNode;
+#else
+						static_cast<const XalanText&>(textNode);
+#endif
+
+				if(!theTextNode.isIgnorableWhitespace())
+				{
+					const XalanDOMString&	data = theTextNode.getData();
+
+					if(0 == length(data))
+					{
+						return true;
+					}
+					else if(!isXMLWhitespace(data))
+					{
+						return false;
+					}
+				}
+
+				XalanNode*	parent = DOMServices::getParentOfNode(textNode);
+
+				while(0 != parent)
+				{
+					if(parent->getNodeType() == XalanNode::ELEMENT_NODE)
+					{
+						const XalanElement*	const	parentElem =
+#if defined(XALAN_OLD_STYLE_CASTS)
+							(const XalanElement*)parent;
+#else
+							static_cast<const XalanElement*>(parent);
+#endif
+
+						XPath::eMatchScore	highPreserveScore = XPath::eMatchScoreNone;
+						XPath::eMatchScore	highStripScore = XPath::eMatchScoreNone;
+
+						ElementPrefixResolverProxy	theProxy(parentElem, m_xpathEnvSupport, m_domSupport);
+
+						{
+							// $$$ ToDo:  All of this should be moved into a member of
+							// Stylesheet, so as not to expose these two data members...
+							typedef Stylesheet::XPathVectorType		XPathVectorType;
+
+							const XPathVectorType&	theElements =
+								m_stylesheetRoot->getWhitespacePreservingElements();
+
+							const XPathVectorType::size_type	nTests =
+								theElements.size();
+
+							for(XPathVectorType::size_type i = 0; i < nTests; i++)
+							{
+								const XPath* const	matchPat = theElements[i];
+								assert(matchPat != 0);
+
+								const XPath::eMatchScore	score = matchPat->getMatchScore(parent, theProxy, executionContext);
+
+								if(score > highPreserveScore)
+									highPreserveScore = score;
+							}
+						}
+
+						{
+							typedef Stylesheet::XPathVectorType		XPathVectorType;
+
+							const XPathVectorType&	theElements =
+								m_stylesheetRoot->getWhitespaceStrippingElements();
+
+							const XPathVectorType::size_type	nTests =
+								theElements.size();
+
+							for(XPathVectorType::size_type i = 0; i < nTests; i++)
+							{
+								const XPath* const	matchPat =
+									theElements[i];
+								assert(matchPat != 0);
+
+								const XPath::eMatchScore	score = matchPat->getMatchScore(parent, theProxy, executionContext);
+
+								if(score > highStripScore)
+									highStripScore = score;
+							}
+						}
+
+						if(highPreserveScore > XPath::eMatchScoreNone ||
+						   highStripScore > XPath::eMatchScoreNone)
+						{
+							if(highPreserveScore > highStripScore)
+							{
+								strip = false;
+							}
+							else if(highStripScore > highPreserveScore)
+							{
+								strip = true;
+							}
+							else
+							{
+								warn("Match conflict between xsl:strip-space and xsl:preserve-space");
+							}
+							break;
+						}
+					}
+
+					parent = parent->getParentNode();
+				}
+			}
+		}
+
+		return strip;
+	}
+}
+
+
+
+XMLParserLiaison&
+XSLTEngineImpl::getXMLParserLiaison() const
+{
+	return m_parserLiaison;
+}
+
+
+
+const XalanDOMString
+XSLTEngineImpl::getUniqueNamespaceValue()
+{
+	XalanDOMString	theResult;
+
+	getUniqueNamespaceValue(theResult);
+
+	return theResult;
+}
+
+
+
+void
+XSLTEngineImpl::getUniqueNamespaceValue(XalanDOMString&		theValue)
+{
+	append(theValue, s_uniqueNamespacePrefix);
+
+	UnsignedLongToDOMString(m_uniqueNSValue++, theValue);
+}
+
+
+
+XalanDocument*
+XSLTEngineImpl::getDOMFactory() const
+{
+	if(m_domResultTreeFactory == 0)
+	{
+#if defined(XALAN_NO_MUTABLE)
+		((XSLTEngineImpl*)this)->m_domResultTreeFactory = m_parserLiaison.createDOMFactory();
+#else
+		m_domResultTreeFactory = m_parserLiaison.createDOMFactory();
+#endif
+	}
+
+	return m_domResultTreeFactory;
+}
+
+
+
+void
+XSLTEngineImpl::setStylesheetParam(
+			const XalanDOMString&	theName,
+			const XalanDOMString&	expression)
+{
+	const XalanQNameByValue		qname(theName, 0, m_xpathEnvSupport, m_domSupport);
+
+	m_topLevelParams.push_back(ParamVectorType::value_type(qname, expression));
+}
+
+
+
+void
+XSLTEngineImpl::setStylesheetParam(
+			const XalanDOMString&	theName,
+			XObjectPtr				theValue)
+{
+	const XalanQNameByValue		qname(theName, 0, m_xpathEnvSupport, m_domSupport);
+
+	m_topLevelParams.push_back(ParamVectorType::value_type(qname, theValue));
+}
+
+
+
+void
+XSLTEngineImpl::resolveTopLevelParams(StylesheetExecutionContext&	executionContext)
+{
+	executionContext.pushTopLevelVariables(m_topLevelParams);
+}
+
+
+
+FormatterListener*
+XSLTEngineImpl::getFormatterListener() const
+{
+	return getFormatterListenerImpl();
+}
+
+
+
+void
+XSLTEngineImpl::setFormatterListener(FormatterListener*		flistener)
+{
+	if (getHasPendingStartDocument() == true && getFormatterListener() != 0)
+	{
+		setMustFlushPendingStartDocument(true);
+
+		flushPending();
+	}
+
+	setFormatterListenerImpl(flistener);
+}
+
+
+
+void
+XSLTEngineImpl::fireCharacterGenerateEvent(
+			const XalanNode&	theNode,
+			bool				isCDATA)
+{
+	fireCharacterGenerateEvent(DOMServices::getNodeData(theNode), isCDATA);
+}
+
+
+
+void
+XSLTEngineImpl::fireCharacterGenerateEvent(
+			const XObjectPtr&	theXObject,
+			bool				isCDATA)
+{
+	fireCharacterGenerateEvent(theXObject->str(), isCDATA);
+}
+
+
+
+void
+XSLTEngineImpl::fireCharacterGenerateEvent(
+			const XalanDOMString&	theString,
+			bool					isCDATA)
+{
+	fireCharacterGenerateEvent(c_wstr(theString), 0, length(theString), isCDATA);
+}
+
+
+
+void
+XSLTEngineImpl::fireCharacterGenerateEvent(
+			const XMLCh*	ch,
+			unsigned int	start,
+			unsigned int	length,
+			bool			isCDATA)
+{
+	const GenerateEvent		ge(
+		isCDATA == true ? GenerateEvent::EVENTTYPE_CDATA : GenerateEvent::EVENTTYPE_CHARACTERS,
+		ch,
+		start,
+		length);
+
+	fireGenerateEvent(ge);
+}
+
+
+
+void
+XSLTEngineImpl::installFunctions()
+{
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("current")), FunctionCurrent());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("document")), FunctionDocument());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("element-available")), FunctionElementAvailable());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("function-available")), FunctionFunctionAvailable());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("format-number")), FunctionFormatNumber());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("generate-id")), FunctionGenerateID());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("key")), FunctionKey());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("system-property")), FunctionSystemProperty());
+	XPath::installFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("unparsed-entity-uri")), FunctionUnparsedEntityURI());
+}
+
+
+
+void
+XSLTEngineImpl::uninstallFunctions()
+{
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("current")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("document")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("element-available")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("function-available")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("format-number")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("generate-id")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("key")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("system-property")));
+	XPath::uninstallFunction(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("unparsed-entity-uri")));
+}
+
+
+
+void
+XSLTEngineImpl::initializeAttributeKeysTable(AttributeKeysMapType&	theAttributeKeys)
+{
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_METHOD] = Constants::TATTRNAME_OUTPUT_METHOD;
+	theAttributeKeys[Constants::ATTRNAME_AMOUNT] = Constants::TATTRNAME_AMOUNT;
+	theAttributeKeys[Constants::ATTRNAME_ANCESTOR] = Constants::TATTRNAME_ANCESTOR;
+	theAttributeKeys[Constants::ATTRNAME_ARCHIVE] = Constants::TATTRNAME_ARCHIVE;
+	theAttributeKeys[Constants::ATTRNAME_ATTRIBUTE] = Constants::TATTRNAME_ATTRIBUTE;
+	theAttributeKeys[Constants::ATTRNAME_ATTRIBUTE_SET] = Constants::TATTRNAME_ATTRIBUTE_SET;
+	theAttributeKeys[Constants::ATTRNAME_CASEORDER] = Constants::TATTRNAME_CASEORDER;
+	theAttributeKeys[Constants::ATTRNAME_CLASS] = Constants::TATTRNAME_CLASS;
+	theAttributeKeys[Constants::ATTRNAME_CLASSID] = Constants::TATTRNAME_CLASSID;
+	theAttributeKeys[Constants::ATTRNAME_CODEBASE] = Constants::TATTRNAME_CODEBASE;
+	theAttributeKeys[Constants::ATTRNAME_CODETYPE] = Constants::TATTRNAME_CODETYPE;
+	theAttributeKeys[Constants::ATTRNAME_CONDITION] = Constants::TATTRNAME_CONDITION;
+	theAttributeKeys[Constants::ATTRNAME_COPYTYPE] = Constants::TATTRNAME_COPYTYPE;
+	theAttributeKeys[Constants::ATTRNAME_COUNT] = Constants::TATTRNAME_COUNT;
+	theAttributeKeys[Constants::ATTRNAME_DATATYPE] = Constants::TATTRNAME_DATATYPE;
+	theAttributeKeys[Constants::ATTRNAME_DEFAULT] = Constants::TATTRNAME_DEFAULT;
+	theAttributeKeys[Constants::ATTRNAME_DEFAULTSPACE] = Constants::TATTRNAME_DEFAULTSPACE;
+	theAttributeKeys[Constants::ATTRNAME_DEPTH] = Constants::TATTRNAME_DEPTH;
+	theAttributeKeys[Constants::ATTRNAME_DIGITGROUPSEP] = Constants::TATTRNAME_DIGITGROUPSEP;
+	theAttributeKeys[Constants::ATTRNAME_DISABLE_OUTPUT_ESCAPING] = Constants::TATTRNAME_DISABLE_OUTPUT_ESCAPING;
+	theAttributeKeys[Constants::ATTRNAME_ELEMENT] = Constants::TATTRNAME_ELEMENT;
+	theAttributeKeys[Constants::ATTRNAME_ELEMENTS] = Constants::TATTRNAME_ELEMENTS;
+	theAttributeKeys[Constants::ATTRNAME_EXPR] = Constants::TATTRNAME_EXPR;
+	theAttributeKeys[Constants::ATTRNAME_EXTENSIONELEMENTPREFIXES] = Constants::TATTRNAME_EXTENSIONELEMENTPREFIXES;
+	theAttributeKeys[Constants::ATTRNAME_FORMAT] = Constants::TATTRNAME_FORMAT;
+	theAttributeKeys[Constants::ATTRNAME_FROM] = Constants::TATTRNAME_FROM;
+	theAttributeKeys[Constants::ATTRNAME_GROUPINGSEPARATOR] = Constants::TATTRNAME_GROUPINGSEPARATOR;
+	theAttributeKeys[Constants::ATTRNAME_GROUPINGSIZE] = Constants::TATTRNAME_GROUPINGSIZE;
+	theAttributeKeys[Constants::ATTRNAME_HREF] = Constants::TATTRNAME_HREF;
+	theAttributeKeys[Constants::ATTRNAME_ID] = Constants::TATTRNAME_ID;
+	theAttributeKeys[Constants::ATTRNAME_IMPORTANCE] = Constants::TATTRNAME_IMPORTANCE;
+	theAttributeKeys[Constants::ATTRNAME_INDENTRESULT] = Constants::TATTRNAME_INDENTRESULT;
+	theAttributeKeys[Constants::ATTRNAME_LANG] = Constants::TATTRNAME_LANG;
+	theAttributeKeys[Constants::ATTRNAME_LETTERVALUE] = Constants::TATTRNAME_LETTERVALUE;
+	theAttributeKeys[Constants::ATTRNAME_LEVEL] = Constants::TATTRNAME_LEVEL;
+	theAttributeKeys[Constants::ATTRNAME_MATCH] = Constants::TATTRNAME_MATCH;
+	theAttributeKeys[Constants::ATTRNAME_METHOD] = Constants::TATTRNAME_METHOD;
+	theAttributeKeys[Constants::ATTRNAME_MODE] = Constants::TATTRNAME_MODE;
+	theAttributeKeys[Constants::ATTRNAME_NAME] = Constants::TATTRNAME_NAME;
+	theAttributeKeys[Constants::ATTRNAME_NAMESPACE] = Constants::TATTRNAME_NAMESPACE;
+	theAttributeKeys[Constants::ATTRNAME_NDIGITSPERGROUP] = Constants::TATTRNAME_NDIGITSPERGROUP;
+	theAttributeKeys[Constants::ATTRNAME_NS] = Constants::TATTRNAME_NS;
+	theAttributeKeys[Constants::ATTRNAME_ONLY] = Constants::TATTRNAME_ONLY;
+	theAttributeKeys[Constants::ATTRNAME_ORDER] = Constants::TATTRNAME_ORDER;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_CDATA_SECTION_ELEMENTS] = Constants::TATTRNAME_OUTPUT_CDATA_SECTION_ELEMENTS;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_DOCTYPE_PUBLIC] = Constants::TATTRNAME_OUTPUT_DOCTYPE_PUBLIC;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_DOCTYPE_SYSTEM] = Constants::TATTRNAME_OUTPUT_DOCTYPE_SYSTEM;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_ENCODING] = Constants::TATTRNAME_OUTPUT_ENCODING;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_INDENT] = Constants::TATTRNAME_OUTPUT_INDENT;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_MEDIATYPE] = Constants::TATTRNAME_OUTPUT_MEDIATYPE;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_STANDALONE] = Constants::TATTRNAME_OUTPUT_STANDALONE;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_VERSION] = Constants::TATTRNAME_OUTPUT_VERSION;
+	theAttributeKeys[Constants::ATTRNAME_OUTPUT_OMITXMLDECL] = Constants::TATTRNAME_OUTPUT_OMITXMLDECL;
+	theAttributeKeys[Constants::ATTRNAME_PRIORITY] = Constants::TATTRNAME_PRIORITY;
+	theAttributeKeys[Constants::ATTRNAME_REFID] = Constants::TATTRNAME_REFID;
+	theAttributeKeys[Constants::ATTRNAME_RESULTNS] = Constants::TATTRNAME_RESULTNS;
+	theAttributeKeys[Constants::ATTRNAME_SELECT] = Constants::TATTRNAME_SELECT;
+	theAttributeKeys[Constants::ATTRNAME_SEQUENCESRC] = Constants::TATTRNAME_SEQUENCESRC;
+	theAttributeKeys[Constants::ATTRNAME_STYLE] = Constants::TATTRNAME_STYLE;
+	theAttributeKeys[Constants::ATTRNAME_TEST] = Constants::TATTRNAME_TEST;
+	theAttributeKeys[Constants::ATTRNAME_TOSTRING] = Constants::TATTRNAME_TOSTRING;
+	theAttributeKeys[Constants::ATTRNAME_TYPE] = Constants::TATTRNAME_TYPE;
+	theAttributeKeys[Constants::ATTRNAME_USE] = Constants::TATTRNAME_USE;
+	theAttributeKeys[Constants::ATTRNAME_USEATTRIBUTESETS] = Constants::TATTRNAME_USEATTRIBUTESETS;
+	theAttributeKeys[Constants::ATTRNAME_VALUE] = Constants::TATTRNAME_VALUE;
+
+	theAttributeKeys[Constants::ATTRNAME_XMLNSDEF] = Constants::TATTRNAME_XMLNSDEF;
+	theAttributeKeys[Constants::ATTRNAME_XMLNS] = Constants::TATTRNAME_XMLNS;
+	theAttributeKeys[Constants::ATTRNAME_XMLSPACE] = Constants::TATTRNAME_XMLSPACE;
+}
+
+
+
+void
+XSLTEngineImpl::initializeElementKeysTable(ElementKeysMapType&	theElementKeys)
+{
+	theElementKeys[Constants::ELEMNAME_APPLY_TEMPLATES_STRING] = Constants::ELEMNAME_APPLY_TEMPLATES;
+	theElementKeys[Constants::ELEMNAME_WITHPARAM_STRING] = Constants::ELEMNAME_WITHPARAM;
+	theElementKeys[Constants::ELEMNAME_CONSTRUCT_STRING] = Constants::ELEMNAME_CONSTRUCT;
+	theElementKeys[Constants::ELEMNAME_CONTENTS_STRING] = Constants::ELEMNAME_CONTENTS;
+	theElementKeys[Constants::ELEMNAME_COPY_STRING] = Constants::ELEMNAME_COPY;
+	theElementKeys[Constants::ELEMNAME_COPY_OF_STRING] = Constants::ELEMNAME_COPY_OF;
+
+	theElementKeys[Constants::ELEMNAME_ATTRIBUTESET_STRING] = Constants::ELEMNAME_DEFINEATTRIBUTESET;
+
+	theElementKeys[Constants::ELEMNAME_USE_STRING] = Constants::ELEMNAME_USE;
+
+	theElementKeys[Constants::ELEMNAME_VARIABLE_STRING] = Constants::ELEMNAME_VARIABLE;
+	theElementKeys[Constants::ELEMNAME_PARAMVARIABLE_STRING] = Constants::ELEMNAME_PARAMVARIABLE;
+
+	theElementKeys[Constants::ELEMNAME_DISPLAYIF_STRING] = Constants::ELEMNAME_DISPLAYIF;
+	theElementKeys[Constants::ELEMNAME_EMPTY_STRING] = Constants::ELEMNAME_EMPTY;
+	theElementKeys[Constants::ELEMNAME_EVAL_STRING] = Constants::ELEMNAME_EVAL;
+	theElementKeys[Constants::ELEMNAME_CALLTEMPLATE_STRING] = Constants::ELEMNAME_CALLTEMPLATE;
+	theElementKeys[Constants::ELEMNAME_TEMPLATE_STRING] = Constants::ELEMNAME_TEMPLATE;
+	theElementKeys[Constants::ELEMNAME_STYLESHEET_STRING] = Constants::ELEMNAME_STYLESHEET;
+	theElementKeys[Constants::ELEMNAME_TRANSFORM_STRING] = Constants::ELEMNAME_STYLESHEET;
+	theElementKeys[Constants::ELEMNAME_IMPORT_STRING] = Constants::ELEMNAME_IMPORT;
+	theElementKeys[Constants::ELEMNAME_INCLUDE_STRING] = Constants::ELEMNAME_INCLUDE;
+	theElementKeys[Constants::ELEMNAME_FOREACH_STRING] = Constants::ELEMNAME_FOREACH;
+	theElementKeys[Constants::ELEMNAME_VALUEOF_STRING] = Constants::ELEMNAME_VALUEOF;
+	theElementKeys[Constants::ELEMNAME_KEY_STRING] = Constants::ELEMNAME_KEY;
+	theElementKeys[Constants::ELEMNAME_STRIPSPACE_STRING] = Constants::ELEMNAME_STRIPSPACE;
+	theElementKeys[Constants::ELEMNAME_PRESERVESPACE_STRING] = Constants::ELEMNAME_PRESERVESPACE;
+	theElementKeys[Constants::ELEMNAME_NUMBER_STRING] = Constants::ELEMNAME_NUMBER;
+	theElementKeys[Constants::ELEMNAME_IF_STRING] = Constants::ELEMNAME_IF;
+	theElementKeys[Constants::ELEMNAME_CHOOSE_STRING] = Constants::ELEMNAME_CHOOSE;
+	theElementKeys[Constants::ELEMNAME_WHEN_STRING] = Constants::ELEMNAME_WHEN;
+	theElementKeys[Constants::ELEMNAME_OTHERWISE_STRING] = Constants::ELEMNAME_OTHERWISE;
+	theElementKeys[Constants::ELEMNAME_TEXT_STRING] = Constants::ELEMNAME_TEXT;
+	theElementKeys[Constants::ELEMNAME_ELEMENT_STRING] = Constants::ELEMNAME_ELEMENT;
+	theElementKeys[Constants::ELEMNAME_ATTRIBUTE_STRING] = Constants::ELEMNAME_ATTRIBUTE;
+	theElementKeys[Constants::ELEMNAME_SORT_STRING] = Constants::ELEMNAME_SORT;
+	theElementKeys[Constants::ELEMNAME_PI_STRING] = Constants::ELEMNAME_PI;
+	theElementKeys[Constants::ELEMNAME_COMMENT_STRING] = Constants::ELEMNAME_COMMENT;
+   
+	theElementKeys[Constants::ELEMNAME_COUNTER_STRING] = Constants::ELEMNAME_COUNTER;
+	theElementKeys[Constants::ELEMNAME_COUNTERS_STRING] = Constants::ELEMNAME_COUNTERS;
+	theElementKeys[Constants::ELEMNAME_COUNTERINCREMENT_STRING] = Constants::ELEMNAME_COUNTERINCREMENT;
+	theElementKeys[Constants::ELEMNAME_COUNTERRESET_STRING] = Constants::ELEMNAME_COUNTERRESET;
+	theElementKeys[Constants::ELEMNAME_COUNTERSCOPE_STRING] = Constants::ELEMNAME_COUNTERSCOPE;
+	
+	theElementKeys[Constants::ELEMNAME_APPLY_IMPORTS_STRING] = Constants::ELEMNAME_APPLY_IMPORTS;
+	
+	theElementKeys[Constants::ELEMNAME_EXTENSION_STRING] = Constants::ELEMNAME_EXTENSION;
+	theElementKeys[Constants::ELEMNAME_MESSAGE_STRING] = Constants::ELEMNAME_MESSAGE;
+	theElementKeys[Constants::ELEMNAME_LOCALE_STRING] = Constants::ELEMNAME_LOCALE;
+	theElementKeys[Constants::ELEMNAME_FALLBACK_STRING] = Constants::ELEMNAME_FALLBACK;
+	theElementKeys[Constants::ELEMNAME_OUTPUT_STRING] = Constants::ELEMNAME_OUTPUT;
+
+	theElementKeys[Constants::ELEMNAME_DECIMALFORMAT_STRING] = Constants::ELEMNAME_DECIMALFORMAT;
+	theElementKeys[Constants::ELEMNAME_NSALIAS_STRING] = Constants::ELEMNAME_NSALIAS;
+}
+
+
+
+void
+XSLTEngineImpl::initializeXSLT4JElementKeys(ElementKeysMapType&		theElementKeys)
+{
+	theElementKeys[Constants::ELEMNAME_COMPONENT_STRING] = Constants::ELEMNAME_COMPONENT;
+	theElementKeys[Constants::ELEMNAME_SCRIPT_STRING] = Constants::ELEMNAME_SCRIPT;
+}
+
+
+
+static XalanDOMString							s_XSLNameSpaceURL;
+
+static XalanDOMString							s_XSLT4JNameSpaceURL;
+
+static XalanDOMString							s_uniqueNamespacePrefix;
+
+static XSLTEngineImpl::AttributeKeysMapType		s_attributeKeys;
+
+static XSLTEngineImpl::ElementKeysMapType		s_elementKeys;
+
+static XSLTEngineImpl::ElementKeysMapType		s_XSLT4JElementKeys;
+
+
+
+const double			XSLTEngineImpl::s_XSLTVerSupported(1.0);
+
+const XalanDOMString&	XSLTEngineImpl::s_XSLNameSpaceURL = ::s_XSLNameSpaceURL;
+
+const XalanDOMString&	XSLTEngineImpl::s_XSLT4JNameSpaceURL = ::s_XSLT4JNameSpaceURL;
+
+const XalanDOMString&	XSLTEngineImpl::s_uniqueNamespacePrefix = ::s_uniqueNamespacePrefix;
+
+
+const XSLTEngineImpl::AttributeKeysMapType&		XSLTEngineImpl::s_attributeKeys = ::s_attributeKeys;
+
+const XSLTEngineImpl::ElementKeysMapType&		XSLTEngineImpl::s_elementKeys = ::s_elementKeys;
+
+const XSLTEngineImpl::ElementKeysMapType&		XSLTEngineImpl::s_XSLT4JElementKeys = ::s_XSLT4JElementKeys;
+
+
+
+void
+XSLTEngineImpl::initialize()
+{
+	::s_XSLNameSpaceURL = XALAN_STATIC_UCODE_STRING("http://www.w3.org/1999/XSL/Transform");
+
+	::s_XSLT4JNameSpaceURL = XALAN_STATIC_UCODE_STRING("http://xml.apache.org/xslt");
+
+	::s_uniqueNamespacePrefix = XALAN_STATIC_UCODE_STRING("ns");
+
+	installFunctions();
+
+	initializeAttributeKeysTable(::s_attributeKeys);
+
+	initializeElementKeysTable(::s_elementKeys);
+
+	initializeXSLT4JElementKeys(::s_XSLT4JElementKeys);
+}
+
+
+
+void
+XSLTEngineImpl::terminate()
+{
+	ElementKeysMapType().swap(::s_XSLT4JElementKeys);
+
+	ElementKeysMapType().swap(::s_elementKeys);
+
+	AttributeKeysMapType().swap(::s_attributeKeys);
+
+	uninstallFunctions();
+
+	releaseMemory(::s_uniqueNamespacePrefix);
+
+	releaseMemory(::s_XSLT4JNameSpaceURL);
+
+	releaseMemory(::s_XSLNameSpaceURL);
+}
diff --git a/src/XalanExtensions/FunctionEvaluate.cpp b/src/XalanExtensions/FunctionEvaluate.cpp
new file mode 100644
index 0000000..90a4ef0
--- /dev/null
+++ b/src/XalanExtensions/FunctionEvaluate.cpp
@@ -0,0 +1,207 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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 "FunctionEvaluate.hpp"
+
+
+
+#include <PlatformSupport/PrefixResolver.hpp>
+
+
+
+#include <XPath/XObjectFactory.hpp>
+#include <XPath/XPath.hpp>
+#include <XPath/XPathProcessorImpl.hpp>
+
+
+
+FunctionEvaluate::FunctionEvaluate()
+{
+}
+
+
+
+FunctionEvaluate::~FunctionEvaluate()
+{
+}
+
+
+
+XObjectPtr
+FunctionEvaluate::execute(
+		XPathExecutionContext&			executionContext,
+		XalanNode*						context)
+{
+	executionContext.error(getError(), context);
+
+	return XObjectPtr(0);
+}
+
+
+
+XObjectPtr
+FunctionEvaluate::execute(
+		XPathExecutionContext&	executionContext,
+		XalanNode*				context,			
+		const XObjectPtr		arg1)
+{
+	assert(arg1.null() == false);	
+
+	const PrefixResolver* const	theResolver =
+		executionContext.getPrefixResolver();
+
+	if (theResolver == 0)
+	{
+		executionContext.warn(
+			"No prefix resolver available in evaluate()!",
+			context);
+
+		return arg1;
+	}
+	else
+	{
+		const XalanDOMString&	theString =
+			arg1->str();
+
+		if (length(theString) == 0)
+		{
+			return XObjectPtr(0);
+		}
+		else
+		{
+			XPathProcessorImpl	theProcessor;
+
+			XPath				theXPath;
+
+			theProcessor.initXPath(
+				theXPath,
+				theString,
+				*theResolver);
+
+			return theXPath.execute(context, *theResolver, executionContext);
+		}
+	}
+}
+
+
+
+XObjectPtr
+FunctionEvaluate::execute(
+			XPathExecutionContext&	executionContext,
+			XalanNode*				context,			
+			const XObjectPtr		/* arg1 */,
+			const XObjectPtr		/* arg2 */)
+{
+	executionContext.error(getError(), context);
+
+	return XObjectPtr(0);
+}
+
+
+
+XObjectPtr
+FunctionEvaluate::execute(
+			XPathExecutionContext&	executionContext,
+			XalanNode*				context,			
+			const XObjectPtr		/* arg1 */,
+			const XObjectPtr		/* arg2 */,
+			const XObjectPtr		/* arg3 */)
+{
+	executionContext.error(getError(), context);
+
+	return XObjectPtr(0);
+}
+
+
+
+XObjectPtr
+FunctionEvaluate::execute(
+			XPathExecutionContext&			executionContext,
+			XalanNode*						context,
+			int								/* opPos */,
+			const XObjectArgVectorType&		args)
+{
+	if (args.size() != 1)
+	{
+		executionContext.error(getError(), context);
+
+		return XObjectPtr(0);
+	}
+	else
+	{
+		return execute(executionContext, context, args[0]);
+	}
+}
+
+
+
+#if defined(XALAN_NO_COVARIANT_RETURN_TYPE)
+Function*
+#else
+FunctionEvaluate*
+#endif
+FunctionEvaluate::clone() const
+{
+	return new FunctionEvaluate(*this);
+}
+
+
+
+const XalanDOMString
+FunctionEvaluate::getError() const
+{
+	return XALAN_STATIC_UCODE_STRING("The evaluate() function takes one argument");
+}
diff --git a/src/XalanSourceTree/XalanSourceTreeParserLiaison.cpp b/src/XalanSourceTree/XalanSourceTreeParserLiaison.cpp
new file mode 100644
index 0000000..f2a98cb
--- /dev/null
+++ b/src/XalanSourceTree/XalanSourceTreeParserLiaison.cpp
@@ -0,0 +1,523 @@
+/*
+ * 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;
+	}
+}
diff --git a/src/XalanTransformer/XalanCompiledStylesheet.hpp b/src/XalanTransformer/XalanCompiledStylesheet.hpp
new file mode 100644
index 0000000..4d174e7
--- /dev/null
+++ b/src/XalanTransformer/XalanCompiledStylesheet.hpp
@@ -0,0 +1,88 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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/>.
+ */
+#if !defined(XALANCOMPILEDSTYLESHEET_HEADER_GUARD)
+#define XALANCOMPILEDSTYLESHEET_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+class StylesheetRoot;
+
+
+
+/**
+ * This is an abstraction of the StylesheetRoot class. It is designed
+ * to allow a XalanTranfomer object to reuse a compliled stylesheet. 
+ */
+class XALAN_TRANSFORMER_EXPORT XalanCompiledStylesheet
+{
+public:
+
+	virtual
+	~XalanCompiledStylesheet() {}
+
+	virtual const StylesheetRoot*
+	getStylesheetRoot() const = 0;
+};
+
+
+
+#endif	// XALANCOMPILEDSTYLESHEET_HEADER_GUARD
diff --git a/src/XalanTransformer/XalanDefaultDocumentBuilder.cpp b/src/XalanTransformer/XalanDefaultDocumentBuilder.cpp
new file mode 100644
index 0000000..9b5782a
--- /dev/null
+++ b/src/XalanTransformer/XalanDefaultDocumentBuilder.cpp
@@ -0,0 +1,130 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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/>.
+ */
+// Class header file.
+#include "XalanDefaultDocumentBuilder.hpp"
+
+
+
+#include <XalanSourceTree/XalanSourceTreeDocument.hpp>
+
+
+
+#include "XalanDefaultParsedSource.hpp"
+
+
+
+XalanDefaultDocumentBuilder::XalanDefaultDocumentBuilder(const XalanDOMString&	theURI) :
+	m_domSupport(),
+	m_parserLiaison(),
+	m_contentHandler(m_parserLiaison.mapDocument(m_parserLiaison.createDocument())),
+	m_uri(theURI)
+{
+	m_domSupport.setParserLiaison(&m_parserLiaison);
+}
+
+
+
+XalanDefaultDocumentBuilder::~XalanDefaultDocumentBuilder()
+{
+}
+
+
+
+XalanDocument*
+XalanDefaultDocumentBuilder::getDocument() const
+{
+	return m_contentHandler.getDocument();
+}
+
+
+
+XalanParsedSourceHelper*
+XalanDefaultDocumentBuilder::createHelper() const
+{
+	return new XalanDefaultParsedSourceHelper(m_domSupport);
+}
+
+
+ContentHandler*
+XalanDefaultDocumentBuilder::getContentHandler()
+{
+	return &m_contentHandler;
+}
+
+
+
+DTDHandler*
+XalanDefaultDocumentBuilder::getDTDHandler()
+{
+	return &m_contentHandler;
+}
+
+
+
+LexicalHandler*
+XalanDefaultDocumentBuilder::getLexicalHandler()
+{
+	return &m_contentHandler;
+}
+
+
+
+const XalanDOMString&
+XalanDefaultDocumentBuilder::getURI() const
+{
+	return m_uri;
+}
diff --git a/src/XalanTransformer/XalanDefaultDocumentBuilder.hpp b/src/XalanTransformer/XalanDefaultDocumentBuilder.hpp
new file mode 100644
index 0000000..c9db42d
--- /dev/null
+++ b/src/XalanTransformer/XalanDefaultDocumentBuilder.hpp
@@ -0,0 +1,126 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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/>.
+ */
+#if !defined(XALANDEFAULTDOCUMENTBUILDER_HEADER_GUARD)
+#define XALANDEFAULTDOCUMENTBUILDER_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+#include <XalanTransformer/XalanDocumentBuilder.hpp>
+
+
+
+#include <XalanSourceTree/XalanSourceTreeContentHandler.hpp>
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
+
+
+
+/**
+ * This is class is designed to allow a XalanTranfomer object
+ * to use a document that is build dynamically by a user.
+ */
+class XALAN_TRANSFORMER_EXPORT XalanDefaultDocumentBuilder : public XalanDocumentBuilder
+{
+public:
+
+	/**
+	 * Create a XalanDefaultDocumentBuilder instance,
+	 *
+	 * @param theURI An optional string to identify the document.
+	 */
+	XalanDefaultDocumentBuilder(const XalanDOMString&	theURI = XalanDOMString());
+
+	virtual
+	~XalanDefaultDocumentBuilder();
+
+	virtual XalanDocument*
+	getDocument() const;
+
+	virtual XalanParsedSourceHelper*
+	createHelper() const;
+
+	virtual const XalanDOMString&
+	getURI() const;
+
+	virtual ContentHandler*
+	getContentHandler();
+
+	virtual DTDHandler*
+	getDTDHandler();
+
+	virtual LexicalHandler*
+	getLexicalHandler();
+
+private:
+
+	XalanSourceTreeDOMSupport		m_domSupport;
+
+	XalanSourceTreeParserLiaison	m_parserLiaison;
+
+	XalanSourceTreeContentHandler	m_contentHandler;
+
+	const XalanDOMString			m_uri;
+};
+
+
+
+#endif	// XALANDEFAULTDOCUMENTBUILDER_HEADER_GUARD
diff --git a/src/XalanTransformer/XalanDefaultParsedSource.cpp b/src/XalanTransformer/XalanDefaultParsedSource.cpp
new file mode 100644
index 0000000..8f3d39f
--- /dev/null
+++ b/src/XalanTransformer/XalanDefaultParsedSource.cpp
@@ -0,0 +1,225 @@
+/*
+ * 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/>.
+ */
+#include "XalanDefaultParsedSource.hpp"
+
+
+
+#include <XalanDOM/XalanDocument.hpp>
+
+
+
+#include <PlatformSupport/URISupport.hpp>
+
+
+
+#include <XalanSourceTree/XalanSourceTreeDocument.hpp>
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+
+
+
+XalanDefaultParsedSourceDOMSupport::XalanDefaultParsedSourceDOMSupport(const XalanSourceTreeDOMSupport&		theDOMSupport) :
+	XalanSourceTreeDOMSupport(),
+	m_domSupport(theDOMSupport)
+{
+}
+
+
+
+XalanDefaultParsedSourceDOMSupport::~XalanDefaultParsedSourceDOMSupport()
+{
+}
+
+
+
+void
+XalanDefaultParsedSourceDOMSupport::reset()
+{
+}
+
+
+
+const XalanDOMString*
+XalanDefaultParsedSourceDOMSupport::getNamespaceForPrefix(
+			const XalanDOMString&	prefix, 
+			const XalanElement&		namespaceContext) const
+{
+	return m_domSupport.getNamespaceForPrefix(
+					prefix, 
+					namespaceContext);
+}
+
+
+
+const XalanDOMString&
+XalanDefaultParsedSourceDOMSupport::getUnparsedEntityURI(
+			const XalanDOMString&	theName,
+			const XalanDocument&	theDocument) const
+{
+	const XalanDOMString&	theURI =
+			m_domSupport.getUnparsedEntityURI(
+					theName,
+					theDocument);
+
+	if (length(theURI) != 0)
+	{
+		return theURI;
+	}
+	else
+	{
+		return XalanSourceTreeDOMSupport::getUnparsedEntityURI(
+					theName,
+					theDocument);
+	}
+}
+
+
+
+bool
+XalanDefaultParsedSourceDOMSupport::isNodeAfter(
+			const XalanNode&	node1,
+			const XalanNode&	node2) const
+{
+	return m_domSupport.isNodeAfter(
+					node1, 
+					node2);
+}
+
+
+
+XalanDefaultParsedSourceHelper::XalanDefaultParsedSourceHelper(const XalanSourceTreeDOMSupport&	theSourceDOMSupport) :
+	m_domSupport(theSourceDOMSupport),
+	m_parserLiaison()
+{
+	m_domSupport.setParserLiaison(&m_parserLiaison);
+}
+
+
+
+DOMSupport&
+XalanDefaultParsedSourceHelper::getDOMSupport()
+{
+	return m_domSupport;
+}
+
+
+
+XMLParserLiaison&
+XalanDefaultParsedSourceHelper::getParserLiaison()
+{
+	return m_parserLiaison;
+}
+
+
+
+XalanDefaultParsedSource::XalanDefaultParsedSource(const XSLTInputSource&	theInputSource):
+	XalanParsedSource(),
+	m_domSupport(),
+	m_parserLiaison(m_domSupport),
+	m_parsedSource(m_parserLiaison.mapDocument(m_parserLiaison.parseXMLStream(theInputSource)))
+{
+	assert(m_parsedSource != 0);
+
+	m_domSupport.setParserLiaison(&m_parserLiaison);
+
+	const XalanDOMChar* const	theSystemID = theInputSource.getSystemId();
+
+	if (theSystemID != 0)
+	{
+		try
+		{
+			m_uri = URISupport::getURLStringFromString(theSystemID);
+		}
+		catch(const XMLException&)
+		{
+			// Assume that any exception here relates to get the url from
+			// the system ID.  We'll assume that it's just a fake base identifier
+			// since the parser would have thrown an error if the system ID
+			// wasn't resolved.
+			m_uri = theSystemID;
+		}
+	}
+}
+
+
+
+XalanDefaultParsedSource::~XalanDefaultParsedSource()
+{
+}
+
+
+
+XalanDocument*	
+XalanDefaultParsedSource::getDocument() const
+{
+	return m_parsedSource;
+}
+
+
+
+XalanParsedSourceHelper*
+XalanDefaultParsedSource::createHelper() const
+{
+	return new XalanDefaultParsedSourceHelper(m_domSupport);
+}
+
+
+
+const XalanDOMString&
+XalanDefaultParsedSource::getURI() const
+{
+	return m_uri;
+}
diff --git a/src/XalanTransformer/XalanDefaultParsedSource.hpp b/src/XalanTransformer/XalanDefaultParsedSource.hpp
new file mode 100644
index 0000000..a4c1408
--- /dev/null
+++ b/src/XalanTransformer/XalanDefaultParsedSource.hpp
@@ -0,0 +1,179 @@
+/*
+ * 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/>.
+ */
+#if !defined(XALANDEFAULTPARSEDSOURCE_HEADER_GUARD)
+#define XALANDEFAULTPARSEDSOURCE_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+
+
+
+#include <XSLT/XSLTInputSource.hpp>
+
+
+
+#include <XalanTransformer/XalanParsedSource.hpp>
+
+
+
+class XalanSourceTreeDocument;
+
+
+
+class XalanDefaultParsedSourceDOMSupport : public XalanSourceTreeDOMSupport
+{
+public:
+
+	XalanDefaultParsedSourceDOMSupport(const XalanSourceTreeDOMSupport&		theDOMSupport);
+
+	virtual
+	~XalanDefaultParsedSourceDOMSupport();
+
+	virtual void
+	reset();
+
+	// These interfaces are inherited from DOMSupport...
+
+	virtual const XalanDOMString*
+	getNamespaceForPrefix(
+			const XalanDOMString&	prefix, 
+			const XalanElement&		namespaceContext) const;
+
+	virtual const XalanDOMString&
+	getUnparsedEntityURI(
+			const XalanDOMString&	theName,
+			const XalanDocument&	theDocument) const;
+
+	virtual bool
+	isNodeAfter(
+			const XalanNode&	node1,
+			const XalanNode&	node2) const;
+
+private:
+
+	const XalanSourceTreeDOMSupport&	m_domSupport;
+};
+
+
+
+class XALAN_TRANSFORMER_EXPORT XalanDefaultParsedSourceHelper : public XalanParsedSourceHelper
+{
+public:
+
+	XalanDefaultParsedSourceHelper(const XalanSourceTreeDOMSupport&	theSourceDOMSupport);
+
+	virtual DOMSupport&
+	getDOMSupport();
+
+	virtual XMLParserLiaison&
+	getParserLiaison();
+
+private:
+
+	XalanDefaultParsedSourceDOMSupport	m_domSupport;
+
+	XalanSourceTreeParserLiaison		m_parserLiaison;
+};
+
+
+
+/**
+ * This is designed to allow a XalanTranfomer object to reuse a parsed
+ * document. 
+ */
+class XALAN_TRANSFORMER_EXPORT XalanDefaultParsedSource : public XalanParsedSource
+{
+public:
+
+	XalanDefaultParsedSource(const XSLTInputSource&		theInputSource);
+
+	virtual
+	~XalanDefaultParsedSource();
+
+	virtual XalanDocument*
+	getDocument() const;
+
+	virtual XalanParsedSourceHelper*
+	createHelper() const;
+
+	virtual const XalanDOMString&
+	getURI() const;
+
+private:
+
+	XalanSourceTreeDOMSupport		m_domSupport;
+
+	XalanSourceTreeParserLiaison	m_parserLiaison;
+
+	XalanSourceTreeDocument* const	m_parsedSource;
+
+	XalanDOMString					m_uri;
+};
+
+
+
+#endif	// XALANDEFAULTPARSEDSOURCE_HEADER_GUARD
+
+
+
diff --git a/src/XalanTransformer/XalanDocumentBuilder.hpp b/src/XalanTransformer/XalanDocumentBuilder.hpp
new file mode 100644
index 0000000..40be256
--- /dev/null
+++ b/src/XalanTransformer/XalanDocumentBuilder.hpp
@@ -0,0 +1,118 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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/>.
+ */
+#if !defined(XALANDOCUMENTBUILDER_HEADER_GUARD)
+#define XALANDOCUMENTBUILDER_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+// Base class include file.
+#include <XalanTransformer/XalanParsedSource.hpp>
+
+
+
+class ContentHandler;
+class DOMSupport;
+class DTDHandler;
+class LexicalHandler;
+class XalanDocument;
+
+
+
+/**
+ * This is abstract base class designed to allow a XalanTranfomer 
+ * object to use a document that is build dynamically by a user.
+ */
+class XALAN_TRANSFORMER_EXPORT XalanDocumentBuilder : public XalanParsedSource
+{
+public:
+
+	virtual
+	~XalanDocumentBuilder()
+	{
+	}
+
+	// These are inherited from XalanParsedSource...
+	virtual XalanDocument*
+	getDocument() const = 0;	
+
+	virtual XalanParsedSourceHelper*
+	createHelper() const = 0;
+
+	virtual const XalanDOMString&
+	getURI() const = 0;
+
+	// These are new to XalanDocumentBuilder...
+	virtual ContentHandler*
+	getContentHandler() = 0;
+
+	virtual DTDHandler*
+	getDTDHandler() = 0;
+
+	virtual LexicalHandler*
+	getLexicalHandler() = 0;
+
+private:
+};
+
+
+
+#endif	// XALANDOCUMENTBUILDER_HEADER_GUARD
diff --git a/src/XalanTransformer/XalanParsedSource.hpp b/src/XalanTransformer/XalanParsedSource.hpp
new file mode 100644
index 0000000..f18ed20
--- /dev/null
+++ b/src/XalanTransformer/XalanParsedSource.hpp
@@ -0,0 +1,154 @@
+/*
+ * 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/>.
+ */
+#if !defined(XALANPARSEDSOURCE_HEADER_GUARD)
+#define XALANPARSEDSOURCE_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+// We're bringing in XalanDocument so that its derivation from XalanNode
+// is known...
+#include <XalanDOM/XalanDocument.hpp>
+
+
+
+class DOMSupport;
+class XMLParserLiaison;
+
+
+
+class XALAN_TRANSFORMER_EXPORT XalanParsedSourceHelper
+{
+public:
+
+	virtual
+	~XalanParsedSourceHelper()
+	{
+	}
+
+	/**
+	 * Get the DOMSupport instance.
+	 *
+	 * @return A reference to a DOMSupport instance.
+	 */
+	virtual DOMSupport&
+	getDOMSupport() = 0;
+
+	/**
+	 * Get the XMLParserLiaison instance.
+	 *
+	 * @return A rerefernce to an XMLParserLiaison instance.
+	 */
+	virtual XMLParserLiaison&
+	getParserLiaison() = 0;
+};
+
+
+
+/**
+ * This is abstract base class designed to allow a XalanTranfomer 
+ * object to reuse a parsed document. 
+ */
+class XALAN_TRANSFORMER_EXPORT XalanParsedSource
+{
+public:
+
+	XalanParsedSource();
+
+	virtual
+	~XalanParsedSource();
+
+	/**
+	 * Get a pointer to the XalanDocument instance for the source
+	 * document
+	 *
+	 * @return A pointer to a XalanDocument instance.
+	 */
+	virtual XalanDocument*
+	getDocument() const = 0;
+
+	/**
+	 * Create the appropriate XalanParsedSourceHelper instance to
+	 * use for transforming with the instance.
+	 *
+	 * The caller is responsible for deleting the object when finished.
+	 *
+	 * @return A pointer to a XalanParsedSourceHelper instance.
+	 */
+	virtual XalanParsedSourceHelper*
+	createHelper() const = 0;
+
+	/**
+	 * Get the URI for the parsed source, if any.
+	 * use for transforming with the instance.
+	 *
+	 * @return A const reference to a string containing the URI
+	 */
+	virtual const XalanDOMString&
+	getURI() const = 0;
+};
+
+
+
+#endif	// XALANPARSEDSOURCE_HEADER_GUARD
+
+
+
diff --git a/src/XalanTransformer/XalanTransformer.cpp b/src/XalanTransformer/XalanTransformer.cpp
new file mode 100644
index 0000000..bf56996
--- /dev/null
+++ b/src/XalanTransformer/XalanTransformer.cpp
@@ -0,0 +1,1142 @@
+/*
+ * The Apache Software License, Version 1.1
+ *
+ *
+ * Copyright (c) 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 "XalanTransformer.hpp"
+
+
+
+#include <algorithm>
+
+
+
+#include <sax/SAXException.hpp>
+
+
+
+#include <XalanDOM/XalanDOMException.hpp>
+
+
+
+#include <PlatformSupport/DOMStringHelper.hpp>
+#include <PlatformSupport/DOMStringPrintWriter.hpp>
+#include <PlatformSupport/XalanOutputStreamPrintWriter.hpp>
+
+
+
+#include <XPath/XObjectFactoryDefault.hpp>
+#include <XPath/XPathFactoryBlock.hpp>
+#include <XPath/XPathFactoryDefault.hpp>
+
+
+
+#include <XSLT/StylesheetConstructionContextDefault.hpp>
+#include <XSLT/StylesheetExecutionContextDefault.hpp>
+#include <XSLT/StylesheetRoot.hpp>
+#include <XSLT/XSLTEngineImpl.hpp>
+#include <XSLT/XSLTInit.hpp>
+#include <XSLT/XSLTProcessorEnvSupportDefault.hpp>
+
+
+
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
+
+
+
+#include <XalanExtensions/XalanExtensions.hpp>
+
+
+
+//#define XALAN_USE_ICU
+#if defined(XALAN_USE_ICU)
+#include <ICUBridge/ICUBridge.hpp>
+#include <ICUBridge/FunctionICUFormatNumber.hpp>
+#include <ICUBridge/ICUBridgeCollationCompareFunctor.hpp>
+#endif
+
+
+
+#include "XalanCompiledStylesheetDefault.hpp"
+#include "XalanDefaultDocumentBuilder.hpp"
+#include "XalanDefaultParsedSource.hpp"
+#include "XalanTransformerOutputStream.hpp"
+#include "XercesDOMParsedSource.hpp"
+
+
+
+const XSLTInit*		XalanTransformer::s_xsltInit = 0;
+
+#if defined(XALAN_USE_ICU)
+static const ICUBridgeCollationCompareFunctor*	theICUFunctor = 0;
+#endif
+
+
+
+XalanTransformer::XalanTransformer():
+	m_compiledStylesheets(),
+	m_parsedSources(),
+	m_paramPairs(),
+	m_functionPairs(),
+	m_errorMessage(1, '\0'),
+	m_stylesheetExecutionContext(new StylesheetExecutionContextDefault)
+{
+#if defined(XALAN_USE_ICU)
+	m_stylesheetExecutionContext->installCollationCompareFunctor(theICUFunctor);
+#endif
+}
+
+
+
+XalanTransformer::~XalanTransformer()
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	// Clean up all entries in the compliledStylesheets vector.
+	for_each(m_compiledStylesheets.begin(),
+			 m_compiledStylesheets.end(),
+			 DeleteFunctor<XalanCompiledStylesheet>());
+
+	// Clean up all entries in the compliledStylesheets vector.
+	for_each(m_parsedSources.begin(),
+			 m_parsedSources.end(),
+			 DeleteFunctor<XalanParsedSource>());
+
+	for (FunctionParamPairVectorType::size_type i = 0; i < m_functionPairs.size(); ++i)
+	{			
+		delete m_functionPairs[i].second;
+	}
+
+	m_functionPairs.clear();
+
+	delete m_stylesheetExecutionContext;
+}
+
+
+
+void
+XalanTransformer::initialize()
+{
+	// Initialize Xalan. 
+	s_xsltInit = new XSLTInit;
+
+	const XalanDOMString	theXalanNamespace(StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("http://xml.apache.org/xalan")));
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("difference")),
+			FunctionDifference());
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("distinct")),
+			FunctionDistinct());
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("evaluate")),
+			FunctionEvaluate());
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("hasSameNodes")),
+			FunctionHasSameNodes());
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("intersection")),
+			FunctionIntersection());
+
+	XalanTransformer::installExternalFunctionGlobal(
+			theXalanNamespace,
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("nodeset")),
+			FunctionNodeSet());
+
+#if defined(XALAN_USE_ICU)
+	theICUFunctor = new ICUBridgeCollationCompareFunctor;
+
+	// Install the ICU version of format-number...
+	XPath::installFunction(
+			StaticStringToDOMString(XALAN_STATIC_UCODE_STRING("format-number")),
+			FunctionICUFormatNumber());
+#endif
+}
+
+
+
+void
+XalanTransformer::terminate()
+{
+	// Terminate Xalan and release memory.
+#if defined(XALAN_CANNOT_DELETE_CONST)
+	(XSLTInit*) s_xsltInit;
+#else
+	delete s_xsltInit;
+#endif
+
+	s_xsltInit = 0;
+
+#if defined(XALAN_USE_ICU)
+#if defined(XALAN_CANNOT_DELETE_CONST)
+	delete (ICUBridgeCollationCompareFunctor*)theICUFunctor;
+#else
+	delete theICUFunctor;
+#endif
+
+	theICUFunctor = 0;
+#endif
+}
+
+
+
+int
+XalanTransformer::transform(
+	const XalanParsedSource&	theParsedXML, 
+	const XSLTInputSource&		theStylesheetSource,
+	const XSLTResultTarget& 	theResultTarget)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	int 	theResult = 0;
+
+	// Clear the error message.
+	m_errorMessage.resize(1, '\0');
+
+	// Store error messages from problem listener.
+	XalanDOMString	theErrorMessage;
+
+	try
+	{
+		XalanDocument* const	theSourceDocument = theParsedXML.getDocument();
+		assert(theSourceDocument != 0);
+
+		// Create the helper object that is necessary for running the processor...
+		XalanAutoPtr<XalanParsedSourceHelper>	theHelper(theParsedXML.createHelper());
+		assert(theHelper.get() != 0);
+
+		DOMSupport& 					theDOMSupport = theHelper->getDOMSupport();
+
+		XMLParserLiaison&				theParserLiaison = theHelper->getParserLiaison();
+
+		// Create some more support objects...
+		XSLTProcessorEnvSupportDefault	theXSLTProcessorEnvSupport;
+
+		XObjectFactoryDefault			theXObjectFactory;
+
+		XPathFactoryDefault 			theXPathFactory;
+
+		// Create a processor...
+		XSLTEngineImpl	theProcessor(
+				theParserLiaison,
+				theXSLTProcessorEnvSupport,
+				theDOMSupport,
+				theXObjectFactory,
+				theXPathFactory);
+
+		theXSLTProcessorEnvSupport.setProcessor(&theProcessor);
+
+		const XalanDOMString&	theSourceURI = theParsedXML.getURI();
+
+		if (length(theSourceURI) > 0)
+		{
+			theXSLTProcessorEnvSupport.setSourceDocument(theSourceURI, theSourceDocument);
+		}
+
+		// Create a problem listener and send output to a XalanDOMString.
+		DOMStringPrintWriter	thePrintWriter(theErrorMessage);
+
+		ProblemListenerDefault	theProblemListener(&thePrintWriter);
+
+		theProcessor.setProblemListener(&theProblemListener);
+
+		theParserLiaison.setExecutionContext(*m_stylesheetExecutionContext);
+
+		// Create a stylesheet construction context, 
+		// using the stylesheet's factory support objects.
+		StylesheetConstructionContextDefault	theStylesheetConstructionContext(
+					theProcessor,
+					theXSLTProcessorEnvSupport,
+					theXPathFactory);
+
+		// Hack used to cast away const.
+		XSLTResultTarget	tempResultTarget(theResultTarget);
+
+		const EnsureReset	theReset(*this);
+
+		// Set up the stylesheet execution context.
+		m_stylesheetExecutionContext->setXPathEnvSupport(&theXSLTProcessorEnvSupport);
+
+		m_stylesheetExecutionContext->setDOMSupport(&theDOMSupport);
+
+		m_stylesheetExecutionContext->setXObjectFactory(&theXObjectFactory);
+
+		m_stylesheetExecutionContext->setXSLTProcessor(&theProcessor);
+
+		// Set the parameters if any.
+		for (ParamPairVectorType::size_type i = 0; i < m_paramPairs.size(); ++i)
+		{
+			theProcessor.setStylesheetParam(
+					m_paramPairs[i].first,
+					m_paramPairs[i].second);
+		}
+
+		// Set the functions if any.
+		for (FunctionParamPairVectorType::size_type f = 0; f < m_functionPairs.size(); ++f)
+		{
+			theXSLTProcessorEnvSupport.installExternalFunctionLocal(
+					m_functionPairs[f].first.getNamespace(),
+					m_functionPairs[f].first.getLocalPart(),
+					*(m_functionPairs[f].second));
+		}
+
+		// Create an input source for the source document...
+		XSLTInputSource		theDocumentInputSource(theSourceDocument);
+
+		// Set the system ID, so relative URIs are resolved properly...
+		theDocumentInputSource.setSystemId(c_wstr(theSourceURI));
+
+		// Do the transformation...
+		theProcessor.process(
+					theDocumentInputSource,
+					theStylesheetSource,
+					tempResultTarget,
+					theStylesheetConstructionContext,
+					*m_stylesheetExecutionContext);
+	}
+	catch (XSLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -1; 	
+	}
+	catch (SAXException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -2;
+	}
+	catch (XMLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -3;
+	}
+	catch(const XalanDOMException&	e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			XalanDOMString theMessage("XalanDOMException caught.  The code is ");
+			
+			append(theMessage,	LongToDOMString(long(e.getExceptionCode())));
+			append(theMessage,	XalanDOMString("."));						 
+
+			TranscodeToLocalCodePage(theMessage, m_errorMessage, true);
+		}
+
+		theResult = -4;
+	}
+
+	return theResult;
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XalanParsedSource&		theParsedXML, 
+			const XalanCompiledStylesheet*	theCompiledStylesheet,
+			const XSLTResultTarget& 		theResultTarget)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::for_each;
+#endif
+
+	int 	theResult = 0;
+
+	// Clear the error message.
+	m_errorMessage.resize(1, '\0');
+
+	// Store error messages from problem listener.
+	XalanDOMString	theErrorMessage;
+
+	try
+	{
+		XalanDocument* const	theSourceDocument = theParsedXML.getDocument();
+		assert(theSourceDocument != 0);
+
+		// Create the helper object that is necessary for running the processor...
+		XalanAutoPtr<XalanParsedSourceHelper>	theHelper(theParsedXML.createHelper());
+		assert(theHelper.get() != 0);
+
+		DOMSupport& 					theDOMSupport = theHelper->getDOMSupport();
+
+		XMLParserLiaison&				theParserLiaison = theHelper->getParserLiaison();
+
+		// Create some more support objects...
+		XSLTProcessorEnvSupportDefault	theXSLTProcessorEnvSupport;
+
+		XObjectFactoryDefault			theXObjectFactory;
+
+		XPathFactoryDefault 			theXPathFactory;
+
+		// Create a processor...
+		XSLTEngineImpl	theProcessor(
+				theParserLiaison,
+				theXSLTProcessorEnvSupport,
+				theDOMSupport,
+				theXObjectFactory,
+				theXPathFactory);
+
+		theXSLTProcessorEnvSupport.setProcessor(&theProcessor);
+
+		const XalanDOMString&	theSourceURI = theParsedXML.getURI();
+
+		if (length(theSourceURI) > 0)
+		{
+			theXSLTProcessorEnvSupport.setSourceDocument(theSourceURI, theSourceDocument);
+		}
+
+		// Create a problem listener and send output to a XalanDOMString.
+		DOMStringPrintWriter	thePrintWriter(theErrorMessage);
+		
+		ProblemListenerDefault	theProblemListener(&thePrintWriter);
+
+		theProcessor.setProblemListener(&theProblemListener);
+
+		// Since the result target is not const in our
+		// internal intefaces, we'll pass in a local copy
+		// of the one provided...
+		XSLTResultTarget	tempResultTarget(theResultTarget);
+
+		const EnsureReset	theReset(*this);
+
+		// Set up the stylesheet execution context.
+		m_stylesheetExecutionContext->setXPathEnvSupport(&theXSLTProcessorEnvSupport);
+
+		m_stylesheetExecutionContext->setDOMSupport(&theDOMSupport);
+
+		m_stylesheetExecutionContext->setXObjectFactory(&theXObjectFactory);
+
+		m_stylesheetExecutionContext->setXSLTProcessor(&theProcessor);
+		
+		// Set the compiled stylesheet.
+		m_stylesheetExecutionContext->setStylesheetRoot(theCompiledStylesheet->getStylesheetRoot());
+
+		// Set the parameters if any.
+		for (ParamPairVectorType::size_type i = 0; i < m_paramPairs.size(); ++i)
+		{
+			theProcessor.setStylesheetParam(
+					m_paramPairs[i].first,
+					m_paramPairs[i].second);
+		}
+
+		// Set the functions if any.
+		for (FunctionParamPairVectorType::size_type f = 0; f < m_functionPairs.size(); ++f)
+		{
+			theXSLTProcessorEnvSupport.installExternalFunctionLocal(
+					m_functionPairs[f].first.getNamespace(),
+					m_functionPairs[f].first.getLocalPart(),
+					*(m_functionPairs[f].second));
+		}
+
+		// Create an input source for the source document...
+		XSLTInputSource		theDocumentInputSource(theSourceDocument);
+
+		// Set the system ID, so relative URIs are resolved properly...
+		theDocumentInputSource.setSystemId(c_wstr(theSourceURI));
+
+		// Do the transformation...
+		theProcessor.process(
+					theDocumentInputSource,
+					tempResultTarget,					
+					*m_stylesheetExecutionContext);
+	}
+	catch (XSLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -1; 	
+	}
+	catch (SAXException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -2;
+	}
+	catch (XMLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -3;
+	}
+	catch(const XalanDOMException&	e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			XalanDOMString theMessage("XalanDOMException caught.  The code is ");
+			
+			append(theMessage,	LongToDOMString(long(e.getExceptionCode())));
+			append(theMessage,	XalanDOMString("."));						 
+
+			TranscodeToLocalCodePage(theMessage, m_errorMessage, true);
+		}
+
+		theResult = -4;
+	}
+
+	return theResult;
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XSLTInputSource&			theInputSource, 
+			const XalanCompiledStylesheet*	theCompiledStylesheet,
+			const XSLTResultTarget& 		theResultTarget)
+{
+	const XalanParsedSource*	theParsedSource = 0;
+ 
+	const int	theResult = parseSource(theInputSource, theParsedSource);
+ 
+	if (theResult != 0)
+	{
+		return theResult;
+	}
+	else
+	{
+		assert(theParsedSource != 0);
+ 
+		// Make sure the parsed source is destroyed when
+		// the transformation is finished...
+		EnsureDestroyParsedSource	theGuard(*this, theParsedSource);
+
+		// Do the transformation...
+		return transform(
+						*theParsedSource,
+						theCompiledStylesheet,
+						theResultTarget);
+	}
+}
+
+int
+XalanTransformer::transform(
+	const XSLTInputSource&		theInputSource, 
+	const XSLTInputSource&		theStylesheetSource,
+	const XSLTResultTarget& 	theResultTarget)
+{
+	// Parse the source document.
+	const XalanParsedSource*	theParsedSource = 0;
+
+	const int	theResult = parseSource(theInputSource, theParsedSource);
+
+	if (theResult != 0)
+	{
+		return theResult;
+	}
+	else
+	{
+		assert(theParsedSource != 0);
+
+		// Make sure the parsed source is destroyed when
+		// the transformation is finished...
+		EnsureDestroyParsedSource	theGuard(*this, theParsedSource);
+
+		// Do the transformation...
+		return transform(
+						*theParsedSource,
+						theStylesheetSource,
+						theResultTarget);
+	}
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XSLTInputSource&		theInputSource, 		
+			const XSLTResultTarget& 	theResultTarget)
+{
+	// Do the transformation...
+	return transform(
+					theInputSource, 
+					XSLTInputSource(),
+					theResultTarget);
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XSLTInputSource&	theInputSource, 
+			const XSLTInputSource&	theStylesheetSource,
+			void*					theOutputHandle, 
+			XalanOutputHandlerType	theOutputHandler,
+			XalanFlushHandlerType	theFlushHandler)
+{
+	// Set to output target to the callback 
+	XalanTransformerOutputStream	theOutputStream(theOutputHandle, theOutputHandler, theFlushHandler);
+
+	XalanOutputStreamPrintWriter	thePrintWriter(theOutputStream);
+
+	XSLTResultTarget				theResultTarget(&thePrintWriter);
+
+	// Do the transformation...
+	return transform(
+					theInputSource, 
+					theStylesheetSource,
+					theResultTarget);
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XalanParsedSource&		theParsedSource, 
+			const XalanCompiledStylesheet*	theCompiledStylesheet,
+			void*							theOutputHandle, 
+			XalanOutputHandlerType			theOutputHandler,
+			XalanFlushHandlerType			theFlushHandler)
+{
+	// Set to output target to the callback 
+	XalanTransformerOutputStream	theOutputStream(theOutputHandle, theOutputHandler, theFlushHandler);
+
+	XalanOutputStreamPrintWriter	thePrintWriter(theOutputStream);
+
+	XSLTResultTarget				theResultTarget(&thePrintWriter);
+
+	// Do the transformation...
+	return transform(
+					theParsedSource,
+					theCompiledStylesheet,
+					theResultTarget);
+}
+
+
+
+int
+XalanTransformer::transform(
+			const XSLTInputSource&		theInputSource, 		
+			void*						theOutputHandle, 
+			XalanOutputHandlerType		theOutputHandler,
+			XalanFlushHandlerType		theFlushHandler)
+{
+	// Set to output target to the callback 
+	XalanTransformerOutputStream	theOutputStream(theOutputHandle, theOutputHandler, theFlushHandler);
+
+	XalanOutputStreamPrintWriter	thePrintWriter(theOutputStream);
+
+	XSLTResultTarget				theResultTarget(&thePrintWriter);
+
+	// Do the transformation...
+	return transform(
+					theInputSource, 
+					XSLTInputSource(),
+					theResultTarget);
+}
+
+
+
+int
+XalanTransformer::compileStylesheet(
+			const XSLTInputSource&				theStylesheetSource,
+			const XalanCompiledStylesheet*& 	theCompiledStylesheet)
+{
+	// Clear the error message.
+	m_errorMessage.resize(1, '\0');
+
+	// Store error messages from problem listener.
+	XalanDOMString	theErrorMessage;
+
+	int 			theResult = 0;
+
+	try
+	{
+		// Create some support objects that are necessary for running the processor...
+		XalanSourceTreeDOMSupport		theDOMSupport;
+
+		XalanSourceTreeParserLiaison	theParserLiaison(theDOMSupport);
+
+		// Hook the two together...
+		theDOMSupport.setParserLiaison(&theParserLiaison);
+
+		// Create some more support objects...
+		XSLTProcessorEnvSupportDefault	theXSLTProcessorEnvSupport;
+
+		XObjectFactoryDefault			theXObjectFactory;
+
+		XPathFactoryDefault 			theXPathFactory;
+
+		// Create a processor...
+		XSLTEngineImpl	theProcessor(
+				theParserLiaison,
+				theXSLTProcessorEnvSupport,
+				theDOMSupport,
+				theXObjectFactory,
+				theXPathFactory);
+
+		// Create a problem listener and send output to a XalanDOMString.
+		DOMStringPrintWriter	thePrintWriter(theErrorMessage);
+
+		ProblemListenerDefault	theProblemListener(&thePrintWriter);
+
+		theProcessor.setProblemListener(&theProblemListener);
+
+		// Create a new XalanCompiledStylesheet.
+		theCompiledStylesheet =
+			new XalanCompiledStylesheetDefault(
+						theStylesheetSource,
+						theXSLTProcessorEnvSupport,
+						theProcessor);
+
+		// Store it in a vector.
+		m_compiledStylesheets.push_back(theCompiledStylesheet);
+	}
+	catch (XSLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -1;
+	}
+	catch (SAXException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -2;
+	}
+	catch (XMLException& e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+		}
+
+		theResult = -3;
+	}
+	catch(const XalanDOMException&	e)
+	{
+		if (length(theErrorMessage) != 0)
+		{
+			TranscodeToLocalCodePage(theErrorMessage, m_errorMessage, true);
+		}
+		else
+		{
+			XalanDOMString theMessage("XalanDOMException caught.  The code is ");
+
+			append(theMessage,	LongToDOMString(long(e.getExceptionCode())));
+
+			append(theMessage,	XalanDOMString("."));
+
+			TranscodeToLocalCodePage(theMessage, m_errorMessage, true);
+		}
+
+		theResult = -4;
+	}
+
+	return theResult;
+}
+
+
+
+int
+XalanTransformer::destroyStylesheet(const XalanCompiledStylesheet*	theStylesheet)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::find;
+#endif
+
+	const CompiledStylesheetPtrVectorType::iterator 	i =
+		find(
+			m_compiledStylesheets.begin(),
+			m_compiledStylesheets.end(),
+			theStylesheet);
+
+	if (i == m_compiledStylesheets.end())
+	{
+		const char* const	theStylesheetErrorMessage =
+				"An invalid compiled stylesheet was provided.";
+
+		const unsigned int	theLength =
+			length(theStylesheetErrorMessage);
+
+		m_errorMessage.resize(theLength + 1, '\0');
+
+		strncpy(&*m_errorMessage.begin(), theStylesheetErrorMessage, theLength);
+
+		return -1;
+	}
+	else
+	{
+		m_compiledStylesheets.erase(i);
+
+#if defined(XALAN_CANNOT_DELETE_CONST)
+		delete (XalanCompiledStylesheet*) theStylesheet;
+#else
+		delete theStylesheet;
+#endif
+
+		return 0;
+	}
+}
+
+
+
+int
+XalanTransformer::parseSource(
+			const XSLTInputSource&		theInputSource,
+			const XalanParsedSource*&	theParsedSource,
+			bool						useXercesDOM)
+{
+	// Clear the error message.
+	m_errorMessage.clear();
+	m_errorMessage.push_back(0);
+
+	int theResult = 0;
+
+	try
+	{
+		if(useXercesDOM == true)
+		{
+			theParsedSource = new XercesDOMParsedSource(theInputSource);
+		}
+		else
+		{
+			theParsedSource = new XalanDefaultParsedSource(theInputSource);
+		}
+
+		// Store it in a vector.
+		m_parsedSources.push_back(theParsedSource);
+	}
+	catch (XSLException& e)
+	{
+		TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+
+		theResult = -1;
+	}
+	catch (SAXException& e)
+	{
+		TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+
+		theResult = -2;
+	}
+	catch (XMLException& e)
+	{
+		TranscodeToLocalCodePage(e.getMessage(), m_errorMessage, true);
+
+		theResult = -3;
+	}
+	catch(const XalanDOMException&	e)
+	{
+		XalanDOMString theMessage("XalanDOMException caught.  The code is ");
+			
+		append(theMessage,	LongToDOMString(long(e.getExceptionCode())));
+
+		append(theMessage,	XalanDOMString("."));						 
+
+		TranscodeToLocalCodePage(theMessage, m_errorMessage, true);
+
+		theResult = -3;
+	}
+
+	return theResult;
+}
+
+
+
+int
+XalanTransformer::destroyParsedSource(const XalanParsedSource*	theParsedSource)
+{
+#if !defined(XALAN_NO_NAMESPACES)
+	using std::find;
+#endif
+
+	const ParsedSourcePtrVectorType::iterator	i =
+		find(
+			m_parsedSources.begin(),
+			m_parsedSources.end(),
+			theParsedSource);
+
+	if (i == m_parsedSources.end())
+	{
+		const char* const	theParsedSourceErrorMessage =
+				"An invalid parsed source was provided.";
+
+		const unsigned int	theLength =
+			length(theParsedSourceErrorMessage);
+
+		m_errorMessage.resize(theLength + 1, '\0');
+
+		strncpy(&*m_errorMessage.begin(), theParsedSourceErrorMessage, theLength);
+
+		return -1;
+	}
+	else
+	{
+		m_parsedSources.erase(i);
+
+#if defined(XALAN_CANNOT_DELETE_CONST)
+		delete (XalanCompiledStylesheet*) theParsedSource;
+#else
+		delete theParsedSource;
+#endif
+
+		return 0;
+	}
+}
+
+
+
+void
+XalanTransformer::setStylesheetParam(
+			const XalanDOMString&	key,
+			const XalanDOMString&	expression)
+{
+	// Store the stylesheet parameter in a vector.
+	m_paramPairs.push_back(ParamPairType(key,  expression));
+}
+
+
+
+XalanDocumentBuilder*
+XalanTransformer::createDocumentBuilder()
+{
+	m_parsedSources.reserve(m_parsedSources.size() + 1);
+
+	XalanDocumentBuilder* const 	theNewBuilder = new XalanDefaultDocumentBuilder;
+
+	m_parsedSources.push_back(theNewBuilder);
+
+	return theNewBuilder;
+}
+
+
+
+void
+XalanTransformer::destroyDocumentBuilder(XalanDocumentBuilder*	theDocumentBuilder)
+{
+	destroyParsedSource(theDocumentBuilder);
+}
+
+
+
+void
+XalanTransformer::installExternalFunction(
+			const XalanDOMString&	theNamespace,
+			const XalanDOMString&	functionName,
+			const Function& 		function)
+{
+	m_functionPairs.push_back(FunctionPairType(XalanQNameByValue(theNamespace, functionName), function.clone()));
+}
+
+
+
+void
+XalanTransformer::installExternalFunctionGlobal(
+			const XalanDOMString&	theNamespace,
+			const XalanDOMString&	functionName,
+			const Function& 		function)
+{
+	XSLTProcessorEnvSupportDefault::installExternalFunctionGlobal(
+			theNamespace,
+			functionName,
+			function);
+}
+
+
+
+void
+XalanTransformer::uninstallExternalFunction(
+			const XalanDOMString&	theNamespace,
+			const XalanDOMString&	functionName)
+{
+	for (FunctionParamPairVectorType::size_type i = 0; i < m_functionPairs.size(); ++i)
+	{
+		if(XalanQNameByReference(theNamespace, functionName).equals(m_functionPairs[i].first))
+		{
+			delete m_functionPairs[i].second;
+
+			m_functionPairs.erase(m_functionPairs.begin() + i); 	
+		}
+	}	
+}
+
+
+
+void
+XalanTransformer::uninstallExternalFunctionGlobal(
+			const XalanDOMString&	theNamespace,
+			const XalanDOMString&	functionName)
+{
+	XSLTProcessorEnvSupportDefault::uninstallExternalFunctionGlobal(
+			theNamespace,
+			functionName);
+}
+
+
+
+
+const char*
+XalanTransformer::getLastError() const
+{
+	return &m_errorMessage[0]; 
+}
+
+
+
+void
+XalanTransformer::reset()
+{
+	try
+	{
+		// Reset objects.
+		m_stylesheetExecutionContext->setXPathEnvSupport(0);
+
+		m_stylesheetExecutionContext->setDOMSupport(0);
+		
+		m_stylesheetExecutionContext->setXObjectFactory(0);
+		
+		m_stylesheetExecutionContext->setXSLTProcessor(0);
+
+		m_stylesheetExecutionContext->reset();
+
+		// Clear the ParamPairVectorType.
+		m_paramPairs.clear();
+	}
+	catch(...)
+	{
+	}
+}
+
+
+
+
+XalanTransformer::EnsureReset::~EnsureReset()
+{
+	m_transformer.m_stylesheetExecutionContext->reset();
+
+	m_transformer.reset();
+}
diff --git a/src/XalanTransformer/XercesDOMParsedSource.cpp b/src/XalanTransformer/XercesDOMParsedSource.cpp
new file mode 100644
index 0000000..b00623c
--- /dev/null
+++ b/src/XalanTransformer/XercesDOMParsedSource.cpp
@@ -0,0 +1,146 @@
+/*
+ * 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/>.
+ */
+#include "XercesDOMParsedSource.hpp"
+
+
+
+#include <XalanDOM/XalanDocument.hpp>
+
+
+
+#include <PlatformSupport/URISupport.hpp>
+
+
+
+class XALAN_TRANSFORMER_EXPORT XercesDOMParsedSourceHelper : public XalanParsedSourceHelper
+{
+public:
+
+	virtual DOMSupport&
+	getDOMSupport()
+	{
+		return m_domSupport;
+	}
+
+	virtual XMLParserLiaison&
+	getParserLiaison()
+	{
+		return m_parserLiaison;
+	}
+
+private:
+
+	XercesDOMSupport		m_domSupport;
+
+	XercesParserLiaison		m_parserLiaison;
+};
+
+
+
+XercesDOMParsedSource::XercesDOMParsedSource(const XSLTInputSource&		theInputSource):
+	XalanParsedSource(),
+	m_parserLiaison(),
+	m_parsedSource(m_parserLiaison.parseXMLStream(theInputSource))
+{
+	const XalanDOMChar* const	theSystemID = theInputSource.getSystemId();
+
+	if (theSystemID != 0)
+	{
+		try
+		{
+			m_uri = URISupport::getURLStringFromString(theSystemID);
+		}
+		catch(const XMLException&)
+		{
+			// Assume that any exception here relates to get the url from
+			// the system ID.  We'll assume that it's just a fake base identifier
+			// since the parser would have thrown an error if the system ID
+			// wasn't resolved.
+			m_uri = theSystemID;
+		}
+	}
+}
+
+
+
+XercesDOMParsedSource::~XercesDOMParsedSource()
+{
+}
+
+
+
+XalanDocument*
+XercesDOMParsedSource::getDocument() const
+{
+	return m_parsedSource;
+}
+
+
+
+XalanParsedSourceHelper*
+XercesDOMParsedSource::createHelper() const
+{
+	return new XercesDOMParsedSourceHelper;
+}
+
+
+
+const XalanDOMString&
+XercesDOMParsedSource::getURI() const
+{
+	return m_uri;
+}
diff --git a/src/XalanTransformer/XercesDOMParsedSource.hpp b/src/XalanTransformer/XercesDOMParsedSource.hpp
new file mode 100644
index 0000000..cd65564
--- /dev/null
+++ b/src/XalanTransformer/XercesDOMParsedSource.hpp
@@ -0,0 +1,116 @@
+/*
+ * 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/>.
+ */
+#if !defined(XERCESDOMPARSEDSOURCE_HEADER_GUARD)
+#define XERCESDOMPARSEDSOURCE_HEADER_GUARD
+
+
+
+// Base include file.  Must be first.
+#include <XalanTransformer/XalanTransformerDefinitions.hpp>
+
+
+
+#include <XalanSourceTree/XalanSourceTreeParserLiaison.hpp>
+#include <XalanSourceTree/XalanSourceTreeDOMSupport.hpp>
+
+
+
+#include <XSLT/XSLTInputSource.hpp>
+
+
+
+#include <XalanTransformer/XalanParsedSource.hpp>
+
+
+
+/**
+ * This is designed to allow a XalanTranfomer object to reuse a parsed
+ * document. 
+ */
+class XALAN_TRANSFORMER_EXPORT XercesDOMParsedSource : public XalanParsedSource
+{
+public:
+	
+	XercesDOMParsedSource(const XSLTInputSource&		theInputSource);
+
+	virtual
+	~XercesDOMParsedSource();
+
+	virtual XalanDocument*
+	getDocument() const;
+
+	virtual XalanParsedSourceHelper*
+	createHelper() const;
+
+	virtual const XalanDOMString&
+	getURI() const;
+
+private:
+
+	XercesParserLiaison		m_parserLiaison;
+
+	XalanDocument* const	m_parsedSource;
+
+	XalanDOMString			m_uri;
+};
+
+
+
+#endif	// XERCESDOMPARSEDSOURCE_HEADER_GUARD
+
+
+