xalan_c-1.12/000755 001751 001751 00000000000 13667130245 013641 5ustar00rleighrleigh000000 000000 xalan_c-1.12/.appveyor.yml000644 001751 001751 00000014735 13667130245 016321 0ustar00rleighrleigh000000 000000 environment: AV_PROJECTS: 'c:\projects' AV_XERCES_SOURCE: 'c:\projects\xerces-c-source' AV_XERCES_BUILD: 'c:\projects\xerces-c-build' AV_XERCES_INSTALL: 'c:\projects\xerces-c' AV_XALAN_DOWNLOAD: 'c:\projects\download' AV_XALAN_TOOLS: 'c:\projects\tools' AV_XALAN_SOURCE: 'c:\projects\xalan-c' AV_XALAN_BUILD: 'c:\projects\build' AV_XALAN_INSTALL: 'c:/projects/libs' matrix: # - compiler: cygwin # configuration: Release # generator: Unix Makefiles # shared: ON # msgloader: inmemory # transcoder: default # - compiler: cygwin # configuration: Debug # generator: Unix Makefiles # shared: OFF # msgloader: # transcoder: - compiler: mingw # configuration: Release # generator: Ninja # shared: ON # msgloader: inmemory # transcoder: # - compiler: mingw # configuration: Debug # generator: Ninja # shared: OFF # msgloader: # transcoder: default - compiler: vc15 configuration: Release generator: Visual Studio 15 2017 Win64 shared: ON msgloader: transcoder: # - compiler: vc15 # configuration: Debug # generator: Visual Studio 15 2017 Win64 # shared: OFF # msgloader: inmemory # transcoder: icu cache: - 'c:\projects\download -> scripts/ci-appveyor-setup' - 'c:\projects\icu -> scripts/ci-appveyor-setup' - 'c:\projects\xerces-c -> scripts/ci-appveyor-setup' - 'c:\tools\vcpkg\installed -> scripts/ci-appveyor-setup' # Operating system (build VM template) os: 'Visual Studio 2017' # clone directory clone_folder: 'c:\projects\xalan-c' clone_depth: 5 platform: x64 init: - set - git config --global core.autocrlf input - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XERCES_SOURCE%`) DO SET AV_XERCES_CYG_SOURCE=%%F' - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XERCES_INSTALL%`) DO SET AV_XERCES_CYG_INSTALL=%%F' - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XALAN_DOWNLOAD%`) DO SET AV_XALAN_CYG_DOWNLOAD=%%F' - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XALAN_TOOLS%`) DO SET AV_XALAN_CYG_TOOLS=%%F' - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XALAN_SOURCE%`) DO SET AV_XALAN_CYG_SOURCE=%%F' - 'FOR /F "tokens=* USEBACKQ" %%F IN (`C:\cygwin64\bin\cygpath -u %AV_XALAN_INSTALL%`) DO SET AV_XALAN_CYG_INSTALL=%%F' - 'if NOT EXIST "%AV_XALAN_DOWNLOAD%\" mkdir %AV_XALAN_DOWNLOAD%' - 'if NOT EXIST "%AV_XALAN_TOOLS%\" mkdir %AV_XALAN_TOOLS%' - 'if %compiler%==cygwin C:\Cygwin64\setup-x86_64 -q -R C:\Cygwin64 -s http://cygwin.mirror.constant.com -l %AV_XALAN_DOWNLOAD%\cygwin -P libcurl-devel,cmake' - set AV_DO_ICU_BUILD=false - set AV_DO_XERCES_BUILD=true - if [%msgloader%] == [icu] set AV_DO_ICU_BUILD=true - if [%transcoder%] == [icu] set AV_DO_ICU_BUILD=true - if [%compiler%] == [vc15] set AV_DO_XERCES_BUILD=false - if [%compiler%] == [vc15] set AV_DO_ICU_BUILD=false - 'if EXIST "%AV_PROJECTS%\icu" AV_DO_ICU_BUILD=false' - 'if EXIST "%AV_PROJECTS%\xerces-c" AV_DO_XERCES_BUILD=false' - 'set "PATH=C:\Program Files (x86)\cmake\bin;%AV_XALAN_TOOLS%;%PATH%"' - 'if %compiler%==cygwin set "PATH=C:\Cygwin64\bin;%PATH%"' - 'if %compiler%==mingw set "PATH=C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin;%PATH%"' - 'if %compiler%==mingw set CC=C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin\gcc' - 'if %compiler%==mingw set CXX=C:\mingw-w64\x86_64-8.1.0-posix-seh-rt_v6-rev0\mingw64\bin\g++' - set "AV_CMAKE_ARGS=-DBUILD_SHARED_LIBS:BOOL=%shared%" - 'if %compiler%==vc15 set "AV_CMAKE_ARGS=%AV_CMAKE_ARGS% -DCMAKE_TOOLCHAIN_FILE:PATH=C:\tools\vcpkg\scripts\buildsystems\vcpkg.cmake"' - if NOT [%msgloader%] == [] set "AV_CMAKE_ARGS=%AV_CMAKE_ARGS% -Dmessage-loader=%msgloader%" - if NOT [%transcoder%] == [] set "AV_CMAKE_ARGS=%AV_CMAKE_ARGS% -Dtranscoder=%transcoder%" - set "AV_XERCES_CMAKE_SOURCE=%AV_XERCES_SOURCE%" - set "AV_XERCES_CMAKE_INSTALL=%AV_XERCES_INSTALL%" - 'if %compiler%==cygwin set "AV_XERCES_CMAKE_SOURCE=%AV_XERCES_CYG_SOURCE%' - 'if %compiler%==cygwin set "AV_XERCES_CMAKE_INSTALL=%AV_XERCES_CYG_INSTALL%' - set "AV_XALAN_CMAKE_SOURCE=%AV_XALAN_SOURCE%" - set "AV_XALAN_CMAKE_INSTALL=%AV_XALAN_INSTALL%" - 'if %compiler%==cygwin set "AV_XALAN_CMAKE_SOURCE=%AV_XALAN_CYG_SOURCE%' - 'if %compiler%==cygwin set "AV_XALAN_CMAKE_INSTALL=%AV_XALAN_CYG_INSTALL%' before_build: - 'C:\cygwin64\bin\bash %AV_XALAN_CYG_SOURCE%/scripts/ci-appveyor-setup' - set ICU_PLATFORM=x64 - if [%platform%] == [x86] set ICU_PLATFORM=Win32 - 'if [%AV_DO_ICU_BUILD%] == [true] cd "%AV_PROJECTS%\icu"' - 'if [%AV_DO_ICU_BUILD%] == [true] echo "Running msbuild to build ICU"' - 'if [%AV_DO_ICU_BUILD%] == [true] call "%VS140COMNTOOLS%..\..\VC\vcvarsall.bat" %platform%' - 'if [%AV_DO_ICU_BUILD%] == [true] msbuild source\allinone\allinone.sln /p:Configuration=%configuration% /p:Platform=%ICU_PLATFORM% /m' - 'if [%AV_DO_ICU_BUILD%] == [true] set "PATH=%AV_PROJECTS%\icu\bin;%AV_PROJECTS%\icu\bin64;%PATH%"' - mkdir %AV_XERCES_BUILD% - cd %AV_XERCES_BUILD% - if [%AV_DO_XERCES_BUILD%] == [true] cmake -G "%generator%" -DCMAKE_INSTALL_PREFIX:PATH=%AV_XERCES_CMAKE_INSTALL% -DCMAKE_BUILD_TYPE=%configuration% "%AV_XERCES_CMAKE_SOURCE%" - if [%AV_DO_XERCES_BUILD%] == [true] cd %AV_XERCES_BUILD% - if [%AV_DO_XERCES_BUILD%] == [true] cmake --build . --config %configuration% - if [%AV_DO_XERCES_BUILD%] == [true] cmake --build . --config %configuration% --target install - 'set "PATH=%AV_XERCES_CMAKE_INSTALL%\bin;%PATH%"' - 'set "PREFIX_PATH=%AV_XERCES_INSTALL%;%AV_PROJECTS%\icu"' - 'if %compiler%==cygwin set "PREFIX_PATH=/cygdrive/c/projects/xerces-c:/cygdrive/c/projects/icu"' - 'echo CPP: %CMAKE_PREFIX_PATH%' - mkdir %AV_XALAN_BUILD% - cd %AV_XALAN_BUILD% - echo Running cmake -G "%generator%" "-DCMAKE_PREFIX_PATH:PATH=%PREFIX_PATH%" "-DCMAKE_INSTALL_PREFIX:PATH=%AV_XALAN_CMAKE_INSTALL%" -DCMAKE_BUILD_TYPE=%configuration% "%AV_XALAN_CMAKE_SOURCE%" - cmake -G "%generator%" "-DCMAKE_PREFIX_PATH:PATH=%PREFIX_PATH%" "-DCMAKE_INSTALL_PREFIX:PATH=%AV_XALAN_CMAKE_INSTALL%" -DCMAKE_BUILD_TYPE=%configuration% %AV_CMAKE_ARGS% "%AV_XALAN_CMAKE_SOURCE%" build_script: - cd %AV_XALAN_BUILD% - cmake --build . --config %configuration% - cmake --build . --config %configuration% --target install after_build: - cd %AV_XALAN_INSTALL% - '7z a %AV_XALAN_SOURCE%\xalan-c.zip * -tzip' before_test: - cd %AV_XALAN_BUILD% - ctest -V -C %configuration% xalan_c-1.12/CMakeLists.txt000644 001751 001751 00000010416 13667130245 016403 0ustar00rleighrleigh000000 000000 # CMake build for xalan-c # # Written by Roger Leigh # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Run "cmake" to generate the build files for your platform cmake_minimum_required(VERSION 3.2.0) # Use new variable expansion policy. if (POLICY CMP0053) cmake_policy(SET CMP0053 NEW) endif(POLICY CMP0053) if (POLICY CMP0054) cmake_policy(SET CMP0054 NEW) endif(POLICY CMP0054) if (POLICY CMP0067) cmake_policy(SET CMP0067 NEW) endif(POLICY CMP0067) # Try C++14, then fall back to C++11 and C++98. Used for feature tests # for optional features. set(CMAKE_CXX_STANDARD 14) # Use folders (for IDE project grouping) set_property(GLOBAL PROPERTY USE_FOLDERS ON) # Source additional modules from the "cmake" directory list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake") # Project version project(xalan-c VERSION 1.12.0 LANGUAGES C CXX) # Library version set(XALAN_LIB_MAJOR_VER 112) set(XALAN_LIB_MINOR_VER 0) set(XALAN_MS_LIB_MAJOR_VER 1) set(XALAN_MS_LIB_MINOR_VER 12) message(STATUS "Configuring Apache Xalan-C++ version ${xalan-c_VERSION}") enable_testing() find_package(Threads REQUIRED) include(Doxygen) include(GNUInstallDirs) include(XalanDLL) include(XalanWarnings) include(XalanFunctions) include(XalanHeaders) include(XalanWindows) include(XalanICU) include(XalanXerces) include(XalanSystemEncodingSelection) include(XalanThreadSelection) include(XalanMsgLoaderSelection) include(XalanTranscoderSelection) include(XalanOperatorDelete) include(XalanPathMax) include(XalanLFS) # Generate pkg-config file set(pkgconfig-dir "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE STRING "pkg-config installation directory (default ${CMAKE_INSTALL_LIBDIR}/pkgconfig)") set(PKGCONFIGDIR "${pkgconfig-dir}") set(prefix "${CMAKE_INSTALL_PREFIX}") set(exec_prefix "${CMAKE_INSTALL_PREFIX}") set(libdir "${CMAKE_INSTALL_FULL_LIBDIR}") set(includedir "${CMAKE_INSTALL_FULL_INCLUDEDIR}") configure_file(${CMAKE_CURRENT_SOURCE_DIR}/xalan-c.pc.in ${CMAKE_CURRENT_BINARY_DIR}/xalan-c.pc) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/xalan-c.pc DESTINATION "${PKGCONFIGDIR}" COMPONENT "development") # Process subdirectories add_subdirectory(src/xalanc/Utils/MsgCreator) add_subdirectory(src/xalanc/Utils) add_subdirectory(src/xalanc/Utils/XalanMsgLib) add_subdirectory(src/xalanc) add_subdirectory(src/xalanc/TestXSLT) add_subdirectory(src/xalanc/TestXPath) add_subdirectory(samples) add_subdirectory(Tests) add_subdirectory(docs/doxygen) # Display configuration summary message(STATUS "") message(STATUS "Xalan-C++ configuration summary") message(STATUS "-------------------------------") message(STATUS "") message(STATUS " Version: ${xalan-c_VERSION}") if(MSVC) message(STATUS " Library major version: ${XALAN_MS_LIB_MAJOR_VER}") message(STATUS " Library minor version: ${XALAN_MS_LIB_MINOR_VER}") else() message(STATUS " Library major version: ${XALAN_LIB_MAJOR_VER}") message(STATUS " Library minor version: ${XALAN_LIB_MINOR_VER}") endif() message(STATUS "") message(STATUS " Installation directory: ${prefix}") message(STATUS " C compiler: ${CMAKE_C_COMPILER}") message(STATUS " C++ compiler: ${CMAKE_CXX_COMPILER}") message(STATUS "") message(STATUS " Build shared libraries: ${BUILD_SHARED_LIBS}") message(STATUS " Thread implementation: ${thread}") message(STATUS " Transcoder: ${transcoder}") message(STATUS " Message Loader: ${msgloader}") message(STATUS " Message Loader Locale: ${message-locale}") xalan_c-1.12/CREDITS000644 001751 001751 00000000201 13667130245 014652 0ustar00rleighrleigh000000 000000 David N Bertoni Scott Boag Shane Curcuru Jack Donohue Paul Dick Emily Farmer Donald Leslie David Marston Myriam Midy Robert Weir xalan_c-1.12/.gitignore000644 001751 001751 00000000604 13667130245 015631 0ustar00rleighrleigh000000 000000 **/Makefile bin/ lib/ nls/ obj/ CMakeCache.txt **/cmake_install.cmake **/CTestTestfile.cmake **/CMakeFiles/ cmake-build* .idea/ xalan-c.pc src/xalanc/NLS/gen/ src/xalanc/NLS/include/ src/xalanc/Xalan **/libxalan-c* **/libxalanMsg* src/xalanc/PlatformSupport/LocalMsgIndex.hpp src/xalanc/Utils/MsgCreator/MsgCreator src/xalanc/XalanCConfig.cmake src/xalanc/XalanCConfigVersion.cmake *.out xalan_c-1.12/samples/000755 001751 001751 00000000000 13667130245 015305 5ustar00rleighrleigh000000 000000 xalan_c-1.12/src/000755 001751 001751 00000000000 13667130245 014430 5ustar00rleighrleigh000000 000000 xalan_c-1.12/Tests/000755 001751 001751 00000000000 13667130245 014743 5ustar00rleighrleigh000000 000000 xalan_c-1.12/NOTICE000755 001751 001751 00000001444 13667130245 014553 0ustar00rleighrleigh000000 000000 ======================================================================= == NOTICE file corresponding to section 4(d) of the Apache License. == == Version 2.0, in this case for the Apache Xalan distribution. == ======================================================================= Apache XALAN-C Copyright (c) 1999-2012 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). This software is based on the ASF XERCES-C project. Portions of this software were originally based on the following: - software copyright (c) 1999, IBM Corporation. (http://www.ibm.com). Additional copyright submissions and contributions: --------------------------------------------------------------------------xalan_c-1.12/KEYS000644 001751 001751 00000021421 13667130245 014337 0ustar00rleighrleigh000000 000000 This file contains the PGP keys of various Xalan-C++ developers. Please don't use them for email unless you have to. Their main purpose is code signing. Xalan users: pgp < KEYS Xalan developers: pgp -kxa and append it to this file. Type Bits/KeyID Date User ID pub 2048/58DA77EA 2002/09/15 David N. Bertoni -----BEGIN PGP PUBLIC KEY BLOCK----- Version: PGP 6.5.8 mQGiBD2EzCURBADvZo0b4zJ1PwLtGAo8dH28LiN+dnhvtfqhTqcGrpZoMta/+h+Y mkr+iLj56VFaAhASdyPij0TRi0MM/KMmhXtoHSOjdWHPRELtbFdfZPSHXKr+GLcb zc2Wk1m0rKMyQil4FeSc3ifUobUwjZl+G0r8bZCcHa6aW8L/BugKmLbE9QCg/0Tc ABLJ0iQoRQ/7/rehDnxrXZUEAOKVEtnrXmYz0oHI1lUQT9qOiCaVn4wUXUfoFZg7 /Zc2Md3D0tVCAa2TIE7KOnlDY7bBem5pNnMZjpQhBiAVc6M21zvbY2ML0j9PUM45 d1tx11UnJb/H/1z41DvNBb0ak/y4yocAFKGtoSGkW06AOKZlDKJt0qyd0A8ri1NQ JWXnBAC5ZryRQvUGVkEBZ+dsUKnieKX7pxXbFO/sc9DHHwv5lIC8sHVanRpS3C3D hvtDtnSA7qOapj120ooooLZH3qerv/FFxcBy3LgHLpOk0OY10sGugbZ++oa7E9ih Fk0gJ6P5Obxdx8NiN49LWjjG0n1K0HQXVQSFSichYX/tOaRmBrQtRGF2aWQgTi4g QmVydG9uaSA8ZGF2aWRfbl9iZXJ0b25pQHVzLmlibS5jb20+iQBOBBARAgAOBQI9 hMwlBAsDAgECGQEACgkQloL2LVjad+p5ggCgjuE8zNBbSv98EMUmoU8C9X1RDJMA nRp+sBbtroBqk/T6iH6DjzV+opXhuQINBD2EzCUQCAD2Qle3CH8IF3KiutapQvMF 6PlTETlPtvFuuUs4INoBp1ajFOmPQFXz0AfGy0OplK33TGSGSfgMg71l6RfUodNQ +PVZX9x2Uk89PY3bzpnhV5JZzf24rnRPxfx2vIPFRzBhznzJZv8V+bv9kV7HAarT W56NoKVyOtQa8L9GAFgr5fSI/VhOSdvNILSd5JEHNmszbDgNRR0PfIizHHxbLY72 88kjwEPwpVsYjY67VYy4XTjTNP18F1dDox0YbN4zISy1Kv884bEpQBgRjXyEpwpy 1obEAxnIByl6ypUM2Zafq9AKUJsCRtMIPWakXUGfnHy9iUsiGSa6q6Jew1XpMgs7 AAICCADyQcz18ke9abv2fG9edtY9GeWGvbel3fPLAB0auZSgxTTTn/EzAiQw/OW9 4LAy6WmsqCNrPI7QTtmubg/h4m6K+4KSuUncxuSoat/R15YJ41r0hKQCRhYS12XD 5QabsUtVcu+eSqpMPTFNPbm7dphpLwyHKp8tGlKOSKX2GDjBndRS//o33V5Jm58N Yk5F9/EcG8wZMMwetl/iKnFuVolZFNG60Ss/D3veIRDNArit+JIsZmYhGlGlNST8 +37lcb8qOaPDIXKidIeJ+eAZQEcWhVUrYK8WLkXqZyGKrpipysWikdsyI4QSHcqt D6Szx+WPRFd9+lm2DMvn0x+RuCemiQBGBBgRAgAGBQI9hMwlAAoJEJaC9i1Y2nfq 0J4AoKXpZ0FzqNUt8DM9CQiU2/aTRUEiAKDvM53DaCeFunbeKXSYgWpYltpzkg== =iRoL -----END PGP PUBLIC KEY BLOCK----- pub 2048/2004CC44 2004-01-13 Matthew Hoyt -----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v1.2.2 (MingW32) mQGiBEAEedERBACXi4mp4oCR/vFC9DYB8p6g7MgtejM9iso0812hi4UAANQp1Cj5 TaKg84EgEs9wqD6yF5Sh5iC+Y2QOrtQQykjh1rbeS6J6jL5SQ4UQvYkEgy7SyqYu mS8tRoR3GCASjYooT3LPoguUPL5nsTFoFyNautS2T91d0Ih0FCBhGr9BpwCg8Uld VsZUBLY5lU/Eoj0/igJN0I8D/RFU7vbzVOGC94UOSJ/2NfdTfHgs3r1Vq0EQQt8B qQ8Qqm1/z1dGmMIPnXcmvwRoUVtq04KWVMqxhDseFxygb5+euyp/AcE3Xt4Z9b4M u6lAstIwXCKYIFGchMMrEHrfyT+T1RnKczPqSJJFqkpWU7jHF88WVxk5yAqLjt1X E59mBACKppza2adeiiK+m3J2VIaeNch5rj9Hp6rt0Tu80ZUh9g24MVq2Mi9kOuy3 LZehxiFIkaMK/k5x6LdNAyCGznVlEXjM9zMWaJjzG+l5HaFOe01ffx1D0x5Z4yCd 8ZxUh3C65Xk5n99PUbCw584iNivmb14cnx/zMoHpSS1UdTjO+LQfTWF0dGhldyBI b3l0IDxtaG95dEBjYS5pYm0uY29tPohbBBMRAgAbBQJABHnRBgsJCAcDAgMVAgMD FgIBAh4BAheAAAoJEFu1ZuAgBMxEcVMAnRsf74lhiwIjK7nvXGyqJN26FHLVAJ9d Fg0oXAXgdGItY/jucjEJVOv2b7kCDQRABHoYEAgAiuY+3ta5yLsjsCmQuVbATFWJ T/oBv900UGeo1yJ10vEQwzFET8OPrUCYW5c+GzaVxonG+YcRAiVlcCXWGolcnMmM UJL8/1mDTSg60oMXdIPtkIh2ogC1VP69uhe1/QQF/tySTO3FAK306u85KYtUyB8L RdUvfRnEocBNRQLX1re5BnhuEvtL+6zTf08IzJlNFol9e5YIlNKxWkQXVweUoXim n0tYeS8qBjLiklD/8ZtXzcr9hZ08Z7YKS/JcPBVuAHdWaRKxVwB92k07NvP70F2I dITqc/Wj8O7Rgemf3uqGR4pMFZrSUycOaEx8kh4SHXb495FzeVeQoF/7SgZsVwAD Bwf+LPJA/sJIP3aCzk/j+rkurx5EOigW85w9cLdQ+bzxS0YhNilsZ0JpfDK99frK Y1XhRn4wjYc/pWodBz7Gz2FE6hP1sBc1cOdRlnBXzxiSvxG+eZo7Ue43W+MVNA+1 Ay7PzYPDBtBgiMUIN1y4WS88Nlh0W4pqt//KkVU+6GuLFG6BMgccA5iGF+XaseT7 crZxPiwgvZ4xIFaHykUM2StDDAxU1sdBVloXzdOvdCJ9+zwS1QIeJHj5re6jlTIE 9J0fw2a8aVFOcNYXt2sj6XF+ChHiXYFqNMuX0uRDYc1ykORzdtnjwEF2FdR+f3eF fvcvEKAE7/zvGhgXOSQoHHWmTohGBBgRAgAGBQJABHoYAAoJEFu1ZuAgBMxEQlUA nA6UswPZaZSipt4MPFIpLSimISlRAKDrIjjI0LE5mvPwbJ+LGIPTCx+ELg== =/gXc -----END PGP PUBLIC KEY BLOCK----- pub 1024D/C7599162 2004-12-21 uid Dmitry Hayes sub 2048g/ACD96CE4 2004-12-21 -----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v1.4.0 (MingW32) mQGiBEHHfq4RBADiF14d67sOzC4T0GfzN+atYrUaV27DiFfg/YZOX2jb2O3ZUamz 8cdJDLpDfRF8WI4QxJDrNZ+a+BGMFnwRj+zBZtcpnH7VbFf3NLT/S0RUjiGoxJnH QhOukyrp3Yfx8AyBSKYXqMnmUsynFpxu+39utUOr+PWkBdgWa7vcLyUDswCg5t0A EB6+tZPF0RSyXLhcaHr0RKsD/3+2FTvlBuaHdE3hNOQJOK5TDbcpgmP+wpOFC2AR sTn3j9nCKItlsO4yC79P1k4L2Jt/wYaNjigRmDr6/YpXdnBFN+TGgBFxU4nTEZXp U1uPxFUoYjtBGfZRlWGUG4TtqQkrHhRhu0VO5r/n7evhHbSSvAFP29hQTD8DLXA6 Y8poA/sEbfPH95XXUURDYDrzOI0ZFXq0UwNk37yJgey9rS4h5Ya2rP20RhQIu47L k87rndugKgXbTl5QEiNOVqMpEOlo68EmCU2jgcPY3DUQhQj8eE+E7qw8T98lwGsL cN4HGCAjv63fkeDJ0ym/KucyMdT3zesO04ejaMcbGQ8aymocZbQhRG1pdHJ5IEhh eWVzIDxkbWl0cnloQGFwYWNoZS5vcmc+iF4EExECAB4FAkHHfq4CGwMGCwkIBwMC AxUCAwMWAgECHgECF4AACgkQP2Ib8MdZkWKBswCdGvMzoTvgid780IanRiDkSbqR QnkAoK77D/zKPNnu8WbQKXtitQHYm3WKuQINBEHHfs4QCACKYPY1LjB+IuM6H/jb HtL5STHEHBIsDOpuiLs/KQvcAvB+Y3A/trVR/Q6tUkSnBLPRzua8suIwyRzanTLv UpFzcz4GgA0TNKxgMueWLEPKxFJD7E8WxA2JFcWTEoVcVCSd1zPYAmK8wHbIFdYG 2yNBxm7N4h/3kftarO1q93shJQDSRNGVOw/L/3PsPHiWjdYIpoCtGHyBFMQxxkZB s3ZIB7lUqqJkVDn0wYKxgaWTEJ8zK5oYNicxqs8tN9NR964UUszHrBGn7hnE0ftX FF5n1pSPJgapCHZBi+BfB0Tr0iHJpiwh926h7B/kUvJjMxm4/xKxrPWLcHoPiKGN hawPAAMFB/9TZtmuvUPk2IjwhlK/aznpTdmEluNDhq0j0UTt+eoUDf/7o5XS/c2x zJuSTjBFTqjoa9koAtViHwHUP+wIRa83Yo04GL1wkIoT/44IJKdRlzF0/GgylPc1 icXb08HaycqotyeZe+zzu5011gRZuknq8vdIaCHGftDtWrhpHKdSywFI4SyCIUD4 QjjlCeOajkoim4SZqyC3X5b6jVVRI1EaUglb+eYAl5sBsOvc5DDjgayCnAtpwMQt e3gs9qR02aTJE4aIJMWTSCJbz9XI9qnnlfUIZq+ZxnPZ0nV9xD+78MtqvLJGgmkB p/XqVQuNZi/O+ZzanUSsEqCkqh2P0BkZiEkEGBECAAkFAkHHfs4CGwwACgkQP2Ib 8MdZkWIn9QCeOtb9ViBk6Vb8otUYUe7TB6BbqgQAn3/zXuskhXAf7HfCENtizTWw 2guD =EET6 -----END PGP PUBLIC KEY BLOCK----- pub 4096R/586A109E 2012-02-26 uid Steven J. Hathaway (Apache Code Signing) -----BEGIN PGP PUBLIC KEY BLOCK----- Version: GnuPG v1.4.10 (GNU/Linux) mQINBE9KohwBEADTnMJHRMlqfolxBQ8ZTd2FpdlV45n/R0FjLyvCR/C8bVTfab3f KGiI2idsXXQHDac770q+xtvyNzy3JPsYfbdv2+uAPKg6Pp2pBPvbP/8TqVB4o0Ty RbmC2SukoFhmqRqsGm+LPiolNe9w8WZkW18Mg3MOFoBlCv0Jm+bQJRWtDRsYE5HI pqWqxX7ZYncQmmcJBKt5kTxOe9e5qaSCwN8MpHXVDHvm+xURIWoF6ODuLl/ZLJz5 5PrVkrd65BajBhbMxJiAxlRPR2okrHOUgGVbTvAitZca44sb02icKOFABKsJ60sK NkIxEDJ5cERCEk+3ixGqrd4pdsRFhDp0gQfgCNQfyZcicejsTXLjAYjy0kX1Sa+q H1t4bMxzUxwQb6+PuSzpq7wmdcNAoYIy+L50yOchf4y2QqPyJ9fYAE7QzcmAYSGV o2RfqJHaday/7noRHheC9tCj9E9lF25ei/Mmqh+0yRiw3XlpRQyDhQ/ASEqCfxSz 2BWv+9D4OuAs7ninHyNrM7bA9QHZn3UWvm5rtfLD2G9AZesEy64DkNnicV9wHF7F AAkj8fEZxtfXQkwmj45LuzbfBWblxDrHxEvn5F9k0gd13LgpKvAeiJCh9miwnd8Y fGL+2p7gEczZ0NB0DAlTehriBQ3AVSHEegK9GksdaRzJE/dAvi3HL7W5GQARAQAB tD9TdGV2ZW4gSi4gSGF0aGF3YXkgKEFwYWNoZSBDb2RlIFNpZ25pbmcpIDxzaGF0 aGF3YXlAYXBhY2hlLm9yZz6JAjcEEwECACECGwMCHgECF4AFAk9KyasFCwkIBwMG FQoJCAsCBBYCAwEACgkQgosaI1hqEJ4OWA//eBlUq+J9uGd2qqVatYXYAuvUf5Eq GwF+KAaMRWv/mK2FRruJGvs35rVhod69ar5SiwmsDJPobKn2rN1HCeUNbxkXxKW+ IW50O6Lvoh57K3+aEg1+qs7r8xlI/QznqH1D7532xJ1sa2AYlhhhr8lNhH9Dw1o3 XgVZq0Ph98vvG0NIs8abIHJF/kqQsR878P1mDiI10f3rILQFTfJ5jvYROEFEwIZw Ek0to/kSikVQve/xzcm9HNsOVMK83MWgLo97bgowEGqYn84K0vE4sjZMr53aYzDa SkFlDQFXR7BoWUk6zgM+Yi5QIaoTsRYROimLldTUpkKa1/yREashrVX04btvXwgV m0tnfab/uHKda5Inn4R3VEjBWYu5n/jF5rarvXbyWpxtLj5SESEUtRn6iSoGroG3 ZkIpY7Z961/Lf0vOCcu3TOJAmAmJs7hn1WkUzl7XIKgR79zh68MWRxqhY8d/cbSd wGjYmxI2E/2afnnlMam5EXWw0u9hlJnnHGWNHhUT3oufmghg5fftWUQ3ORsfSjtu KMKsblVgW0GldcP7vKrs1UvYSCq7nRgqgAgjwnO0BAVvz6nstQKlry1cR6MBLSDT NSFX8f9VnPCqFze2ynNHOqXhPKA99eCXIXRgKxRTTSdsuyb4fX8lpH5P2Pw/7Jo6 Q3SkDyHOe8OZhoyZAQ0ET0qi5gEIALPzRUK0gQcwO/jaxnqq1XgXaiQiYNiWr6eY /rV1DUkLm6Of4drBlW8A0LmZcuTYnx2mxsoLnVL0SKHiJ/wKmWSyA+nZH4n2Ar4o XqJ5nl4GjIS6gGOkBJCfNaxhGh744O7O2su5HKuluq80x0mH3iMs7COO4NO1R7YW mrxiP/4EsIL0FFhtiV1JF6J2wSqu/RV1cSLDn8lAALKvz9288wu8wH6df6ioPp3K KEyqwjWb/fRHKYeho7KPcRgnqFJhUn8n9CC35xadqJUjNOWciLT3YCJSkhM73GU9 n0xucs74xsMcBwEKiYEKMYI/1JlmQlkfP0o7zr+5ZuQoOIFw5mcAEQEAAbQ2U3Rl dmVuIEouIEhhdGhhd2F5IChBcGFjaGUgUEdQKSA8c2hhdGhhd2F5QGFwYWNoZS5v cmc+iQE2BBMBAgAgAhsDAh4BAheABQJPSsppBQsJCAcDBRUKCQgLBBYCAwEACgkQ HCOyNmSmoLrByQgAj1DfNcnnnLxT+vIBhgNfdwhQZpgKywgu0XVZ3nyhU9kTdRqe 8Nf6Wz+ez6OJpTDPzC9nDjHcurTXBoCQ0LBPrcSMMEn3/3J/kSYNHicO7u44hJCL /Vv6xcFerqy0+rK7RUqSILGX31PJJr65+OMQC/EPP1fOBojtB49KchFxrP8j406w cbMVnKF6H9CbMcopwrmqda1CDjj1arJyLIpifG29t70hhT+miIJDyXIiExwOLwiS mlG3RQvTEl15ClYTpfvFRR8eaJVqHb3R8pfo+0XeGswRD3eys/Z4PzjoecS5IPbp QTwujmolpUzIw/cV3WLbUwBwpVmnVd2txXxz4bkBDQRPSqLmAQgAwHKAaMCiYYl9 gQRrW/vSih5B7UTxX63ZnkhyTwMEKRc95w30H4GY72JsLk0lzPiUMYDOV17Y8nYf uKM355YNqK6yZ3XIT6yPsmTlC3HFGno56bPNSKbIxZEXIvY3ITLyN7mhDvGxCq3U 8XvM/XLk46VgYPY4qly/yQ5ASeYs75FBep+Ns0Gv4Asampw5l5itbiMBIUZ84TYW 05K7YmMbVsQFhlaBNY8ke5fLbqjQHB3K2SO62HLOPqehx+ZbMHIP+TtcJDxEXK+0 OnomYKR5FuQZe3P95CorhoZG3DiNCEBiTjegkBZgtISyELO1hJEFAJ2ouwZPT45/ pSwX5tXWgQARAQABiQEfBBgBAgAJBQJPSqLmAhsMAAoJEBwjsjZkpqC6RzYH/A7p zAiQaQ4m+tiEpFXKqkt7MLUa5JB4ggKEnQ0Za7GJBvtH2ruwnqpTno7uwtsGzHGV /V9JBpo7G5p228bh7gmET7kEnuCQMIuHz2v2wtMpxejDmo+TFqhoVuL7IaWMxwHX HKo7MUf2YN1I/lRi0goCx7gEdJangtRmqLoyhjQKi6NmEBy3lihyODt8kAIowMtG b8tCfoq+YqZpVjHPDVhXr/q7dm1nrneI5KGPt6ceZEUfQzjX/L1nl2TCSMlI/2WA JVs/N4xcYH+5vEGou2xoE/X6uonxhbbmtGisQRfFf/kVDMcB7eD2HrJZoQy2AwVp 3JQv88HXJk79iaam8tc= =MBu4 -----END PGP PUBLIC KEY BLOCK----- xalan_c-1.12/.travis.yml000644 001751 001751 00000001321 13667130245 015747 0ustar00rleighrleigh000000 000000 language: c dist: bionic cache: directories: - download addons: apt_packages: - libxerces-c-dev - libicu-dev - libcurl4-openssl-dev - autoconf - automake - libtool - cmake - ninja-build before_install: - if test "$(uname -s)" = Darwin; then brew update ; fi - if test "$(uname -s)" = Darwin; then brew install xerces-c icu4c || true; fi - if test "$(uname -s)" = Darwin; then brew install ninja ; fi os: - linux - osx env: - TOOL="Unix Makefiles" TYPE=Debug MSGLOADER=inmemory TRANSCODER=default - TOOL="Ninja" TYPE=Release MSGLOADER=inmemory TRANSCODER=icu jobs: fast_finish: true script: - ./scripts/ci-travis "$TOOL" "$TYPE" "$MSGLOADER" "$TRANSCODER" xalan_c-1.12/LICENSE000644 001751 001751 00000026137 13667130245 014657 0ustar00rleighrleigh000000 000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. xalan_c-1.12/cmake/000755 001751 001751 00000000000 13667130245 014721 5ustar00rleighrleigh000000 000000 xalan_c-1.12/docs/000755 001751 001751 00000000000 13667130245 014571 5ustar00rleighrleigh000000 000000 xalan_c-1.12/readme.html000644 001751 001751 00000001766 13667130245 015776 0ustar00rleighrleigh000000 000000 Redirecting to Xalan-C++ Overview xalan_c-1.12/xalan-c.pc.in000644 001751 001751 00000000324 13667130245 016114 0ustar00rleighrleigh000000 000000 prefix=@prefix@ exec_prefix=@exec_prefix@ libdir=@libdir@ includedir=@includedir@ Name: Xalan-C Description: XSLT library for C/C++ Version: @xalan_c_version@ Libs: -L${libdir} -lxalan-c Cflags: -I${includedir} xalan_c-1.12/scripts/000755 001751 001751 00000000000 13667130245 015330 5ustar00rleighrleigh000000 000000 xalan_c-1.12/README.md000644 001751 001751 00000001261 13667130245 015120 0ustar00rleighrleigh000000 000000 # Apache Xalan-C/C++ XSLT Library ![Xalan-C++-logo](docs/images/xalan-small.svg) ## Overview The Apache Xalan-C++ Project provides a library and a command line program to transform XML documents using a stylesheet that conforms to XSLT 1.0 standards. Xalan is a project of the Apache Software Foundation. ## Links * [Project Website](http://xalan.apache.org/xalan-c/) * Source Repository: see [GitHub](https://github.com/apache/xalan-c) or [Apache GitBox](https://gitbox.apache.org/repos/asf?p=xalan-c.git) * [Downloads](http://www.apache.org/dyn/mirrors/mirrors.cgi/xalan/xalan-c) ## Documentation [Table of Contents](docs/index.md) ![Apache-logo](docs/images/asf-small.svg) xalan_c-1.12/scripts/ci-travis000755 001751 001751 00000001572 13667130245 017164 0ustar00rleighrleigh000000 000000 #!/bin/sh # This script is used for testing the build, primarily for use # with travis, but may be used by hand as well. set -e set -x # Test autoconf build cmake_build() { opts="" if [ -n "$3" ]; then opts="$opts -Dmessage-loader=$3" fi if [ -n "$4" ]; then opts="$opts -Dtranscoder=$4" fi PATH="$(pwd)/tools/bin:$PATH" if [ "$(uname -s)" = "Darwin" ]; then PATH="$(pwd)/tools/CMake.app/Contents/bin:$PATH" opts="$opts -DICU_ROOT=/usr/local/opt/icu4c" fi mkdir cmake-build cd cmake-build echo "Running cmake -G "$1" -DCMAKE_BUILD_TYPE="$2" -DCMAKE_INSTALL_PREFIX=../cmake-install ${opts} .." cmake -G "$1" -DCMAKE_BUILD_TYPE="$2" -DCMAKE_INSTALL_PREFIX=../cmake-install ${opts} .. cmake --build . cmake --build . --target install ctest -V } echo "Testing CMake build" cmake_build "$@" exit 0 xalan_c-1.12/scripts/ci-appveyor-setup000755 001751 001751 00000002243 13667130245 020653 0ustar00rleighrleigh000000 000000 #!c:/cygwin64/bin/bash set -e set -x PATH="/cygdrive/c/cygwin64/bin:$PATH" download_file() ( url="$1" file="$2" hash="$3" hash_output="${hash} *$file" if [ ! -f "$file" ]; then echo "Downloading $file" else if [ "$(sha512sum "$file")" != "$hash_output" ]; then echo "$file sha512sum mismatch" fi fi if [ ! -f "$file" ] || [ "$(sha512sum "$file")" != "$hash_output" ]; then rm -f "$file" curl -L -o "$file" "$url" fi [ "$(sha512sum "$file")" = "$hash_output" ] ) xerces_git_uri="https://github.com/apache/xerces-c.git" xerces_git_branch="v3.2.3" if [ "$compiler" = "vc15" ]; then ( if [ ! -f /cygdrive/c/tools/vcpkg/installed/x64-windows/bin/xerces-c_3_2.dll ]; then cd "$(cygpath -u "c:\\tools\\vcpkg")" git pull ./bootstrap-vcpkg.bat ./vcpkg install xerces-c:x64-windows if [ "$transcoder" = "icu" ]; then vcpkg install icu:x64-windows fi fi ) else ( cd "$AV_PROJECTS" echo "AV_XERCES_SOURCE=$AV_XERCES_SOURCE" echo "cygpath AV_XERCES_SOURCE=$(cygpath -u "${AV_XERCES_SOURCE}")" git clone -b "$xerces_git_branch" "$xerces_git_uri" "$(cygpath -u "${AV_XERCES_SOURCE}")" ) fi xalan_c-1.12/docs/overview.md000644 001751 001751 00000015230 13667130245 016762 0ustar00rleighrleigh000000 000000 # Xalan-C++ Overview ## Introduction Xalan-C++ (named after a rare musical instrument) implements the [W3C Recommendation 16 November 1999 XSL Transformations (XSLT) Version 1.0](http://www.w3.org/TR/xslt) and the [XML Path Language (XPath) Version 1.0](http://www.w3.org/TR/xpath). XSLT is the first part of the XSL stylesheet language for XML. It includes the XSL Transformation vocabulary and XPath, a language for addressing parts of XML documents. For links to background materials, discussion groups, frequently asked questions, and tutorials on XSLT, see [Getting up to speed with XSLT](#getting-up-to-speed-with-xslt). Note: XSL also includes a vocabulary for formatting documents, which is not part of Xalan-C++. For more information, see [Extensible Stylesheet Language (XSL) Version 1.0 W3C Recommendation](http://www.w3.org/TR/xsl) and the [Apache XML FOP (Formatting Objects Project)](http://xmlgraphics.apache.org/fop). You use the XSLT language to compose XSL stylesheets. An XSL stylesheet contains instructions for transforming XML documents from one document type to another document type (XML, HTML, or other). In structural terms, an XSL stylesheet specifies the transformation of one tree of nodes (the XML input) into another tree of nodes (the output or transformation result). Note: The XSL stylesheet may generate and refer to cascading style sheets ([CSS](http://www.w3.org/Style/CSS/)) as part of its output. In the following example, the *foo.xsl* stylesheet is used to transform *foo.xml* into *foo.out*: *foo.xml*: ```xml Hello ``` *foo.xsl*: ```xml ``` *foo.out*: ```xml Hello ``` ## Xalan-C++ Features * Xalan-C++ fully implements the [W3C Recommendation 16 November 1999 XSL Transformations (XSLT) Version 1.0](http://www.w3.org/TR/xslt). * Xalan-C++ incorporates the [XML Path Language (XPath) Version 1.0](http://www.w3.org/TR/xpath). * Xalan-C++ uses [Xerces-C++](http://xerces.apache.org/xerces-c/index.html) to parse XML documents and XSL stylesheets. The input may appear in the form of a file or URL, a stream, or a [DOM](http://www.w3.org/DOM). Xalan-C++ performs the transformations specified in the XSL stylesheet and produces a file, a stream, or a DOM as you specify when you set up the transformation. * Along with a complete API for performing transformations in your C++ applications, Xalan-C++ provides a [commandline](commandline.md) utility for convenient file-to-file transformations. * Xalan-C++ supports C++ [extension functions](extensions.md). ## Getting to work with Xalan-C++ For instructions and some suggestions about how to get started using Xalan-C++, see [Building Xalan-C++](build.md) and [Installing Xalan-C++](install.md). ## Getting up to speed with XSLT If you are still working through the details of the XSLT spec (the W3C 1.0 Recommendation), you may want to consult one or more of the following: * Crane Softwright's [Free preview of Practical Transformation Using XSLT and XPath](http://www.CraneSoftwrights.com/training/) * Doug Tidwell's [XSLT](http://www.oreilly.com/catalog/xslt/), O'Reilly, 2001 * Bob DuCharme's [XSLT Quickly](http://www.manning.com/ducharme/index.html), Manning Publications, 2001 * John Robert Gardner and Zarella Rendon's [XSLT and XPath: A Guide to Transformations](http://vig.prenhall.com/catalog/academic/product/1,4096,0130404462,00.html), Prentice-Hall, 2001 * Elliotte Rusty Harold's [Chapter 17 of the XML Bible: XSL Transformations](http://www.ibiblio.org/xml/books/bible2/chapters/ch17.html) * The Mulberry [XSL-List -- Open Forum on XSL](http://www.mulberrytech.com/xsl/xsl-list/) (of interest to XSL users at all levels) * Objects by Design's [Transforming XMI to HTML](http://www.objectsbydesign.com/projects/xmi_to_html.html) (oriented towards XMI, "an XML-based, stream representation of a UML model," but also covers "generic" XML transformations) and their related [XSLT by Example](http://objectsbydesign.com/projects/xslt/xslt_by_example.html) * OASIS (the Organization for the Advancement of Structured Information Standards): [Extensible Stylesheet Language (XSL)](http://www.oasis-open.org/cover/xsl.html) by Robin Cover * Aaron Skonnard and Martin Gudgin's [Essential XML Quick Reference](http://www.theserverside.net/tt/books/addisonwesley/EssentialXML/index.tss"): A Programmer's Reference to XML, XPath, XSLT, XML Schema, SOAP and More. This reference is published by Addison Wesley, 2003, ISBN/0201740958. When you come across other useful introductory or background materials, please email the Xalan Development Mailing List, so we can add them to this list. ## Glossary
XSLT Namespace
The XML namespace for XSLT. An XML namespace is a collection of element and attribute names, identified by a Unique Resource Identifier (URI), which often takes the form of a URL, but is really just a unique string, not a pointer to a web page. The XSLT namespace URI is `http://www.w3.org/1999/XSL/Transform`. In each XSLT stylesheet, you must declare this namespace in the stylesheet element tag and bind it to a local prefix. Like the XSLT specification, we always use xsl as the XSLT namespace prefix in our descriptions and examples, although you are free to bind any prefix to this namespace.

XSL Instruction
Any tag associated with the XSLT namespace.

Template
An element, usually with child elements, that specifies a "rule" or set of instructions to perform when a particular kind of node is encountered in the source tree.

XSL Template Instruction
Any tag that occurs inside an xsl:template element and is associated with the XSLT namespace.

Source Tree
The XML tree input to the XSL process.

Result Tree
The tree that is output by the XSL process.

Match Pattern
The part of a template that defines the kind(s) of nodes to which the template applies.


For more definitions of XSLT terminology, see Dave Pawson's [XSLT Terminology Clarification](http://www.dpawson.co.uk/xsl/xslvocab.html) and the Glossary in Michael Kay's [XSLT Programmer's Reference](http://www.wrox.com/Consumer/Store/Details.asp?ISBN=1861003129). xalan_c-1.12/docs/index.md000644 001751 001751 00000001621 13667130245 016222 0ustar00rleighrleigh000000 000000 # Xalan-C++ Documentation ![Xalan-C++-logo](images/xalan-small.svg) ## Table of Contents ### Introduction [Introduction](introduction.md) ### Xalan project information [Main Xalan website](http://xalan.apache.org/) [Release history](releases.md) [Licensing](licensing.md) [Charter](charter.md) [Frequently asked questions](faq.md) [To-do tasks for future releases](todo.md) ### Using Xalan-C++ [Overview](overview.md) [Command-Line Utilities](commandline.md) [Extensions library](extensionslib.md) ### Developing with Xalan-C++ [Basic usage patterns](usagepatterns.md) [Programming tips](programming.md) [Extension functions](extensions.md) [Samples](samples.md) [XML Security Overview](secureweb.md) [API reference](api) ### Obtaining Xalan-C++ [Downloading Xalan-C++](download.md) [Building Xalan-C++](build.md) [Installing Xalan-C++](install.md) ![Apache-logo](images/asf-small.svg) xalan_c-1.12/docs/faq.md000644 001751 001751 00000044425 13667130245 015673 0ustar00rleighrleigh000000 000000 # Frequently asked questions ## Where do I go to learn about XSLT *Where do I go to learn about XSLT?* The definitive sources are the W3C XSLT and XPath recommendations: [W3C Recommendation 16 November 1999 XSL Transformations (XSLT) Version 1.0](http://www.w3.org/TR/xslt) and [XML Path Language (XPath) Version 1.0](http://www.w3.org/TR/xpath). For a brief listing of tutorials, discussion forums, and other materials, see [Getting up to speed with XSLT](overview.md#getting-up-to-speed-with-xslt). ## Asking questions about Xalan-C++ *Where can I ask a question?* For specific questions on Xalan-C++, see list archives: [xalan-c-users](http://marc.info/?l=xalan-c-users) and [xalan-dev](http://marc.info/?l=xalan-dev). You must subscribe to these Apache mailing lists before posting your questions. The Apache Software Foundation has information on how you can subscribe to the [mailing lists](http://www.apache.org/foundation/mailinglists.html). You can post messages to the lists by sending mail to: * `c-users@xalan.apache.org` (user's list) * `dev@xalan.apache.org` (developer's list) Again, please review the archives before posting a new question. ## What is Xerces-C++? *What is Xerces-C++ and why do I need it?* Xerces-C++ is a validating XML parser written in a portable subset of C++. Xerces-C++ makes it easy to give your application the ability to read and write XML data. Like Xalan-C++, Xerces-C++ is available from the Apache XML site: [http://xerces.apache.org](http://xerces.apache.org). ## Which version of Xerces-C++ should I be using? *Which version of Xerces-C++ should I be using?* The Xalan-C++ release notes includes information about the Xerces-C++ release with which the Xalan-C++ release has been coordinated and tested. See the [release history](releases.md). ## Should I be using the Xerces DOM or Xalan DOM? *Should I be using the Xerces DOM or Xalan DOM?* The Xalan DOM implementation is highly optimised for transformations. However, whilst you can build documents in the Xalan DOM, subsequent modification will not work. The Xalan DOM is designed to be either an input or an output from a transformation, not as a general DOM implementation. So in cases where you want to simply transform documents using Xalan, using the internal DOM implementation is the best approach. In cases where you want to modify the DOM document on the fly, you should use the Xerces DOM as the base document. You can wrap the Xerces DOM in a wrapper (see [Passing in a Xerces DOM](usagepatterns.md#passing-in-a-xerces-dom-to-a-transformation)) to then use as an input to a Xalan transformation. Alternatively you can output the result of a transformation to a Xerces DOM document (see [Working with DOM input and output](usagepatterns.md#working-with-dom-input-and-output)). In either case, the Xerces document can be freely modified. However, after you modify the document, you need to re-build the wrapper so that any changes are replicated in the Xalan wrappers. ## Problems with samples in Windows *I have encountered problem executing the Xalan-C++ sample applications after rebuilding them under Win32 Environment (Windows NT 4.0, SP3). When I tried to execute the sample, I receive the error message `Debug Assertion Failed! … Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)`.* You may be mixing debug and release versions of executables and libraries. In other words, if you are compiling the sample for debug, then you should link with the debug version of the Xalan-C++ and Xerces-C++ libraries and run with the debug version of the dynamic link libraries. You must also make sure your application is linking with the "Debug Multithreaded DLL" run-time library or the "Multithreaded DLL" run-time library. To check this setting do the following in Visual C++: 1. Select "Settings" from the "Project" menu. 2. Click the "C/C++" tab. 3. In the Category drop-down list, select "Code Generation". 4. In the "Use run-time library" drop-down list, select "Multithreaded DLL" for the "Win32 Release" configuration, or select "Debug Multithreaded DLL" for the "Win32 Debug" configuration. Once you have changed this setting, you must rebuild your project. Note: This FAQ entry is largely historical. While mixing Release and Debug builds and different runtimes is still inadvisable, the CMake build system should link the correct versions of the libraries and prevent this happening by accident. ## Building on Windows *What do I need to rebuild Xalan-C++ on Windows?* For more details, see [Downloading Xalan-C++](download.md) and [Building Xalan-C++](build.md). ## Building on UNIX *What do I need to rebuild Xalan-C++ on UNIX?* For more details, see [Downloading Xalan-C++](download.md) and [Building Xalan-C++](build.md). ## What is ICU *What is ICU and why do I need it?* The [International Components for Unicode (ICU)](http://icu-project.org/) is a C and C++ library that provides robust and full-featured Unicode support on a wide variety of platforms. Xalan-C++ uses the ICU to extend support for encoding, number formatting, and sorting. Xalan should work with any release of ICU from the past decade. For more details see [Using the International Components for Unicode (ICU)](usagepatterns.md#using-the-icu). ## A tar checksum error on Solaris *I am getting a tar checksum error on Solaris. What's the problem?* The Solaris tar utility you are using does not properly handle files with long pathnames. You must use GNU tar (gtar), which handles arbitrarily long pathnames and is freely available on every platform on which Xalan-C++ is supported. If you don't already have GNU tar installed on your system, you can obtain it from the Free Software Foundation [http://www.gnu.org/software/tar/tar.html](http://www.gnu.org/software/tar/tar.html). For additional background information on this problem, see the online manual [GNU tar and POSIX tar](http://www.gnu.org/manual/tar/html_chapter/tar_8.html#SEC112) for the utility. ## Xalan-C++ in Apache *Is it possible to run Xalan-C++ from an Apache server?* A simple Apache module called [ApacheModuleXSLT](samples.md#apachemodulexslt) is provided as a sample. It demonstrates how to integrate Xalan-C++ with Apache. ## Is Xalan-C++ thread-safe? *Is Xalan-C++ thread-safe?* Instances of [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) are not thread-safe; each thread should use its own instance. In order to support very efficient use in multi-threaded applications, Xalan-C++ is designed to avoid synchronization as much as possible. Each thread of execution is required to have its own set of "support" objects that contain the state of the transformation. Accordingly, no synchronization is required when multiple threads are executing. Parsed ("compiled") stylesheets (see [Performing a series of transformations](usagepatterns.md#performing-a-series-of-transformations)) and parsed source documents may be freely shared by multiple threads of execution without worrying about providing synchronized access to them. The *only* exception to this rule: You use [`XercesParserLiaison`](https://apache.github.io/xalan-c/api/classxalanc_1_1XercesParserLiaison.html) to parse a document after calling [`XercesParserLiaison::setBuildBridgeNodes(false)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XercesParserLiaison.html#a01a4d6c3abaeb09738d555814ef7194c) or [`XercesParserLiaison::setThreadSafe(false)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XercesParserLiaison.html#af8dc3b5cfae5dd9a1cbdf446e369b9c9). In this case, the document *cannot* be shared by multiple threads of execution. For reasons of performance, we do not recommend the use of `XercesParserLiaison`, so this should not be an issue for most applications. All other objects in Xalan-C++ are *not* thread-safe. Each thread must have its own instance of each object. See the [ThreadSafe](samples.md#threadsafe) sample program for more information. ## What can I do to speed up transformations? *What can I do to speed up transformations?* To maximize performance, here are some suggestions for you to keep in mind as you set up your applications: * Use a compiled stylesheet when you expect to use the stylesheet more than once. * Set up your stylesheets to function efficiently. * Don't use `//` (descendant axes) patterns near the root of a large document. * Use `xsl:key` elements and the `key()` function as an efficient way to retrieve node sets. * Where possible, use pattern matching rather than `xsl:if` or `xsl:when` statements. * `xsl:for-each` is fast because it does not require pattern matching. * Keep in mind that `xsl:sort` prevents incremental processing. * When you create variables, `` is usually faster than ``. * Be careful using the `last()` function. * The use of index predicates within match patterns can be expensive. ## Stylesheet validation *Can I validate an XSL stylesheet?* An XSL stylesheet is an XML document, so it can have a `DOCTYPE` and be subject to validation, but you probably will have to write a custom DTD for the purpose. The XSLT Recommendation includes a [DTD Fragment for XSL Stylesheets](http://www.w3.org/TR/xslt#dtd) with some indications of what you need to do to create a complete DTD for a given stylesheet. Keep in mind that stylesheets can include literal result elements and produce output that is not valid XML. You can use the `xsl:stylesheet` doctype defined in `xsl-html40s.dtd` for stylesheets that generate HTML. ## What does the XalanDOMException HIERARCHY_REQUEST_ERR mean? *What does the [`XalanDOMException`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanDOMException.html) [`HIERARCHY_REQUEST_ERR`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanDOMException.html#a7ace065fde4b86526306d2c9ca3ab074a1333e25db8de187d2caee6513cc9dcc4) mean?* It means that an attempt was made to add a node to a DOM that would create an invalid structure. For example, text nodes are not allowed as children of the document node. This is a common error when attempting to transform to DOM. Source documents and stylesheets that might produce valid serialized XML might not produce a valid DOM. The usual suspect is text nodes being generated before the document element is generated. If you think you have seen this error because of a bug in Xalan-C++'s source tree implementation, please post a bug report on [Jira](https://issues.apache.org/jira/browse/XALANC), and attach a minimal source document and stylesheet that produce the problem to the bug report. ## Submitting Patches *Who do I submit patches to?* Your contributions are much appreciated! You can e-mail your patches to the Xalan Development Mailing List or raise an issue on the [Jira issue tracking system](https://issues.apache.org/jira/browse/XALANC). The Xalan projects use Jira as the issue tracking system. Any significant bug or feature request is posted to this system. You must subscribe to the system in order to submit patches and raise issues. * Subscribe to Jira at: [https://issues.apache.org/jira](https://issues.apache.org/jira) * Browse the issues at: [https://issues.apache.org/jira/browse/XALANC](https://issues.apache.org/jira/browse/XALANC) Issues posted to the project on Jira at `XALANC` are automatically posted to the Xalan Development Mailing List. Our mailing lists are moderated. You should subscribe to the mailing list in order to post a message, otherwise message delivery requires manual intervention or may be dropped. ## Transformation Output Methods *How do I output a transformation to a DOM, a file, an in-memory buffer, or as input to another transformation?* Since the C++ language can automatically construct an [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html) from any of its constructor's argument types, you usually don't need to create one explicitly. The output parameter of [`XalanTransformer::transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4) is an [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html) which has many constructors. Output to a file: * The easiest way is to use a null-terminated string containing the file name to create an `XSLTResultTarget`. Or, use an instance of `std::ofstream`. The command line executables, and many of the sample applications use file names, so take a look through the source code for more information. Output to an in-memory buffer: * Use an instance of `std::ostrstream` or `std::ostringstream` to create an XSLTResultTarget. See the StreamTransform sample for more information. Input to another transformation: * Any of the previous output targets could be used as the input to another transformation, but the [`FormatterToSourceTree`](https://apache.github.io/xalan-c/api/classxalanc_1_1FormatterToSourceTree.html) is probably the best for efficiency reasons. See the source code for the `TestXSLT` command line program for more information. ## Problems Using Sun's Forte/Workshop Compiler with code containing std::istrstream *Why won't XSLTInputSource work with `std::istrstream` on Sun Solaris using Forte/Sun Workshop compiler?* There is a bug in Sun's C++ standard library implementation for the Forte/Workshop compiler. The short answer is that you need to get a patch. The issue is resolved if you use the SunStudio platform for your code development. The Solaris SunStudio is now available from Oracle. ## Modifying an instance of XalanDocument *My transformation outputs to a [`XalanDocument`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanDocument.html) (actually [`XalanSourceTreeDocument`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanSourceTreeDocument.html) underneath) but W3C DOM functions like `DOMElement::setAttribute` don't work! Am I going crazy or what?* No, you aren't going crazy. Xalan's default source tree is read-only for efficiency. If you need a DOM that supports modifications, use the Xerces DOM instead. See the [TransformToXercesDOM](samples.md#transformtoxercesdom) sample for more information. ## Changing Where Error Output is Sent *XalanTransformer outputs errors to the console. How do I, for example, output error to a file?* By default, [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) creates a [`XalanTransformerProblemListener`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformerProblemListener.html) (a subclass of [`ProblemListener`](https://apache.github.io/xalan-c/api/classxalanc_1_1ProblemListener.html)) that writes output to `std::cerr`. To change this you can: * Redirect `std::cerr` from the command line. * Call [`XalanTranformer::setWarningStream`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a1c7826710c68a6311329ef7be65253e6) with a different `std::ostream` before calling [`XalanTransformer::transform`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4). * Instantiate your own [`XalanTransformerProblemListener`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformerProblemListener.html) with a different output stream and call [`XalanTransformer::setProblemListener()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3dda165f568b89e02bcbf2f56508ec7a) before calling [`XalanTransformer::transform`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4). * Subclass some [`ProblemListener`](https://apache.github.io/xalan-c/api/classxalanc_1_1ProblemListener.html) type and do custom handling of errors (you still then need to tell [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) instances to use your `ProblemListener`). In most cases you probably want to do one of the first two. ## Programmatic Error Information *How do I programmatically get the file name, line number, and column number for an error in an XML file?* Create a custom `ErrorHandler` (a Xerces-C++ class) and call [`XalanTransformer::setErrorHandler`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#af3eff73a57f2998a2b440c2c4f105371) before parsing any sources. ## String Transcoding *How do I make a `char*` out of [`XalanDOMString`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanDOMString.html) (or vice-versa)?* See the static method [`XalanDOMString::transcode`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanDOMString.html#a0b7ab1c0f2ea4615962437b8837e11d7), or the functions [`TranscodeToLocalCodePage`](https://apache.github.io/xalan-c/api/namespacexalanc.html#ada7c55659cbbc92271ac1fa128afa07b). However, you should be very careful when transcoding Unicode characters to the local code page, because not all Unicode characters can be represented. ## Error Code/Exception Summary *Is there a table of error codes somewhere? How about a summary of what methods throw which exceptions?* There isn't, but we're working on it. ## Extension Functions *The Xalan extension functions (`xalan:node-set()`, etc.) don't work for me. Help!* Did you declare the namespace on the `xsl:stylesheet` or `xsl:transform` element? It should look like this: ```xml …rest of stylesheet ``` If you did and you still have problems, you might want to ask the mailing list. ## Using format-number and ICU *Why does Xalan emit a warning when using the XSLT function `format-number()`?* Did you build with ICU support? See [Using the International Components for Unicode (ICU)](usagepatterns.md#using-the-icu). ## Perl wrapper for Xalan-C++? *Is there a Perl wrapper for Xalan-C++?* There is no Apache Perl wrapper, however Edwin Pratomo has written a wrapper for Xalan-C++ version 1.4 that can be found on CPAN. ## Missing *LocalMsgIndex.hpp* file *Why can't I find the *LocalMsgIndex.hpp* file?* The *LocalMsgIndex.hpp* file is not shipped with the source distributions because this file is generated during the build process, customized for the locale and message set you are using. The *LocalMsgIndex.hpp* file is a member of the *include/xalanc/PlatformSupport* directory. xalan_c-1.12/docs/todo.md000644 001751 001751 00000000433 13667130245 016060 0ustar00rleighrleigh000000 000000 # To-do tasks for future releases * Update the documentation * Performance improvements * Add a more complete set of EXSLT functions * Add support for extension elements * Fix any conformance bugs we or our users find * Fix compiler and platform support issues * Add XPath2 support xalan_c-1.12/docs/install.md000644 001751 001751 00000002663 13667130245 016570 0ustar00rleighrleigh000000 000000 # Installing Xalan-C++ Prebuilt packages of Xalan-C++ are not provided by the Apache Xalan-C++ project. However, several organisations provide binary builds of Xalan-C++. Existing providers include: | OS | Distributor | Package | |---------|---------------|---------| | BSD | FreeBSD Ports | [xalan-c](https://svnweb.freebsd.org/ports/head/textproc/xalan-c/) | | Linux | Debian | [libxalan-c-dev](https://packages.debian.org/search?keywords=libxalan-c-dev&searchon=names&suite=all§ion=all) | | Linux | Fedora and EPEL (for RHEL and CentOS) | [xalan-c-devel](https://apps.fedoraproject.org/packages/xalan-c-devel) | | Linux | Gentoo | [dev-libs/xalan-c](https://packages.gentoo.org/packages/dev-libs/xalan-c) | | Linux | Ubuntu | [libxalan-c-dev](https://packages.ubuntu.com/search?suite=all&arch=any&searchon=names&keywords=libxalan-c-dev) | | macOS | [Homebrew](https://brew.sh) | [xalan-c](https://formulae.brew.sh/formula/xalan-c#default) | | macOS | [MacPorts](https://www.macports.org) | [xalanc](https://www.macports.org/ports.php?by=name&substr=xalanc) | | Windows | [vcpkg](https://github.com/microsoft/vcpkg) | [xalan-c](https://github.com/microsoft/vcpkg/blob/master/ports/xalan-c/CONTROL) | The table above is by no means exhaustive. Other distributors may also provide binary packages for their platforms. Once installed from a prebuilt package, Xalan-C++ should be immediately ready to use. xalan_c-1.12/docs/samples.md000644 001751 001751 00000037517 13667130245 016574 0ustar00rleighrleigh000000 000000 # Xalan-C++ Samples ## Samples to help you get started Each of the subdirectories in the Xalan-C++ [*samples*](https://github.com/apache/xalan-c/tree/master/samples) directory contains the source files for a sample application. With most of the samples, you can use the following procedure: 1. Go to the samples subdirectory containing the sample (use the CMD shell or PowerShell if you are running Windows) 2. Run the sample from the command line (as indicated below) 3. Examine the application source files. You may also want to modify the source files. Remember that if you modify a *.cpp* file, you must rebuild the executable and place it on the path before you can run the modified application. Note: Each sample application looks for input files in the current directory, the directory from which you run the application. The input files are in the samples subdirectory along with the sample source files. The location of the sample executables may vary depending upon the CMake generator used for building. They should typically be located within the *builddir/samples/\*. In all cases, be sure the sample executable is on the `PATH`, and run it from the samples subdirectory that contains the input files. Note: The most of the samples are implemented without providing a pluggable memory manager. [SimpleTransform](#simpletransform) sample illustrates, in addition to a simple transformation, the usage of the processor with memory manager. ## ApacheModuleXSLT Note: This sample must be built with the Apache Web server. What it does: runs as an Apache module on an Apache Web server; performs transformations and returns the output to a Web browser. You configure Apache to respond to a given URL request for an output file (html or txt file in the configuration below) by applying an XSL stylesheet file to an XML document file (both with the specified name in a given location) and returning the transformation output to the client. This sample also illustrates use of the [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) class and the C API defined in [*xalanc/XalanTransformer/XalanCAPI.h*](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#ab9ec00bf3fbe6a946e20418a53891755). It returns transformation output in blocks to a callback function, which enables the browser to start displaying the result before the transformation has been completed. Note: You may need to configure CMake to locate the required Apache header files. ### Setting up and using ApacheModuleXSLT To use `ApacheModuleXSLT`, do the following: 1. (UNIX only) Be sure the Xalan and Xerces libraries are on your system library path, and copy the Apache module to */usr/lib/apache*. 2. Add `LoadModule` and (UNIX only) `AddModule` entries to the Apache configuration file, *httpd.conf*. Windows: `LoadModule xslt_module Xalan-C_1_12_0;-\bin\ApacheModuleXSLT.dll` UNIX: `AddModule mod_xslt.c` and `LoadModule xslt_module /usr/lib/apache/mod_xslt.xx` where `xx` is the appropriate library suffix for the UNIX platform ("*.so*" or "*.a*"). 3. Add a `` entry to `httpd.conf` that indicates where *.xml* and *.xsl* file pairs are to be found, and what target file extensions to recognize. We suggest the following: ```xml AddHandler mod_xslt .html AddHandler mod_xslt .txt ``` This element instructs the module to respond to requests for *xxx.html* and *xxx.txt* files in the in the *xslt* subdirectory (under the document root; see next item) by applying the *xxx.xsl* stylesheet to *xxx.xml* (both in that directory) and returning the transformation result to the browser.
For example, a request for *foo.html* instructs the module to apply *foo.xsl* to *foo.xml* and return the result.
Note: It is up to the stylesheet to apply the appropriate `xsl:output` method to the output. Whether the user specifies `html` or `txt` is, of itself, immaterial. 4. Put *.xml* and *.xsl* file pairs in the `` subdirectory (*xslt* in the example) under the document root directory specified in *httpd.conf* by the `DocumentRoot` and `` settings. Alternatively, you can modify these settings to point to *samples/ApacheModuleXSLT*, which includes an *xslt* subdirectory with *.xml* and *.xsl* file pairs (*foo.xml* and *foo.xsl*, *apachemod.xml* and *apachemod.xsl*). 5. Start the Apache server. 6. From a Web browser, call the module with a URL as follows: `http://serverName/xslt/xxx.html` where `serverName` is the Apache server (such as `www.myServer.com`) and `xxx` is the name of an XML/XSL pair of files (such as *foo.xml* and *foo.xsl*) in the *xslt* subdirectory under the `DocumentRoot` directory.
For example, `http://www.myServer.com/xslt/apachemod.html` instructs `ApacheModuleXSLT` to apply the *apachemod.xsl* stylesheet to the *apachemod.xml* XML document (both files in the *xslt* directory under the Apache `DocumentRoot` directory) and return the transformation result to the browser. ## CompileStylesheet What it does: Use a compiled stylesheet to perform a series of transformations. You can run it from the *CompileStylesheet* subdirectory with `CompileStylesheet` See also: [Performing a series of transformations](usagepatterns.md#performing-a-series-of-transformations). ## DocumentBuilder What it does: Use a `DocumentBuilder` to programmatically construct an XML document, apply the *foo.xsl* stylesheet to this document, and write the ouput to *foo.out*. You can run it from the *DocumentBuilder* subdirectory with `DocumentBuilder`. ## ExternalFunction What it does: implement, install, and illustrate the usage of three extension functions. The functions return a square root, a cube, and a string with the current date and time. The sample stylesheet (*foo.xsl*) gets the area of a cube and units of measurement from an XML document (*foo.xml*), computes the length of each side of a cube and the volume of the cube, and enters the date and time of the transformation. The output appears in *foo.out*. Run this sample from the *ExternalFunction* subdirectory with `ExternalFunction`. See also: [Extension Functions](faq.md#extension-functions). ## ParsedSourceWrappers What it does: performs a transformation with input in the form of a pre-built `XercesDOM` or `XalanSourceTree`. Run this sample from the *ParsedSourceWrappers* subdirectory with `ParsedSourceWrappers` See `transformXercesDOM()` and `transformXalanSourceTree()` as called by `transform()` in *ParsedSourceWrappers.cpp*. ## SerializeNodeSet What it does: Serialize the node set returned by the application of an XPath expression to an XML document. Run this sample from the *SerializeNodeSet* subdirectory with ```sh SerializeNodeSet XMLFile ContextNode XPathExpression ``` where *XMLFile* is an XML source file, *ContextNode* is the location path to the context node, and *XPathExpression* is an XPath expression to apply to that context node. The *SerializeNodeSet* directory contains the same *foo.xml* sample source file as the preceding examples. ## SimpleTransform What it does: The `SimpleTransform` class uses the *foo.xsl* stylesheet to transform *foo.xml*, and writes the output to *foo.out*. The source for this sample has been modified to demonstrate the usage of the new pluggable memory management feature. You can run it from the *SimpleTransform* subdirectory with `SimpleTransform`. See also: [Basic procedures for performing XSL transformations](usagepatterns.md#xalan-c-basic-usage-patterns). ## SimpleXPathAPI What it does: Use the `XPathEvaluator` interface to evaluate an XPath expression from the specified context node of an XML file and display the nodeset returned by the expression. Note: You can use this sample as an aid when you want to find out what a given XPath expression returns from a given context node in an XML file. Run this sample from the *SimpleXPathAPI* subdirectory with: ```sh SimpleXPathAPI XMLFile ContextNode XPathExpression ``` where *XMLFile* is an XML source file, *ContextNode* is the location path to the context node, and *XPathExpression* is an XPath expression to apply to that context node. Keep in mind that the string value returned by an XPath expression is the string value of the first node in the nodeset returned by the expresssion. The *XPathWrapper* subdirectory contains an XML file named *xml.foo* (part of it appears below). ```xml Mr. Marson Mr. Bertoni … Mr. Dick ``` You can try command lines like ```sh SimpleXPathAPI foo.xml /foo:doc foo:name/@last ``` and ```sh SimpleXPathAPI foo.xml / '//foo:name[position()="4"]/@first' ``` Note: If a `SimpleXPathAPI` argument includes characters (such as `*`) that the shell interprets incorrectly, enclose the argument in double quotes. See also: [Working with XPath expressions](usagepatterns.md#working-with-xpath-expressions). ## SimpleXPathCAPI What it does: Use the [`XPathEvaluator`](https://apache.github.io/xalan-c/api/classxalanc_1_1XPathEvaluator.html) C interface to evaluate an XPath expression and display the string value returned by the expression. Note: Keep in mind that the string value returned by an XPath expression is the string value of the first node in the nodeset returned by the expresssion. Run this sample from the *SimpleXPathCAPI* subdirectory with: ```sh SimpleXPathCAPI XMLFile XPathExpression ``` where *XMLFile* is an XML source file, and *XPathExpression* is an XPath expression to apply to the XML source file. The *SimpleXPathCAPI* subdirectory contains an XML file named *foo.xml* similar to the *foo.xml* in the preceding example. You can try command lines like: ```sh SimpleXPathCAPI foo.xml /doc/name[3] ``` ## StreamTransform What it does: The `StreamTransform` class processes character input streams containing a stylesheet and an XML document, and writes the transformation output to a character output stream. This sample illustrates the process for working with stylesheets and documents that you assemble in memory. You can run it from the *SimpleTransform* subdirectory with `StreamTransform`. ## ThreadSafe What it does: Multiple threads use a single compiled stylesheet (`StylesheetRoot`) and DOM source tree (`XalanNode`) to perform transformations concurrently. The application tracks the progress of the threads in messages to the console, and each thread writes its own output file. Imagine a server application responding to multiple clients who happen to request the same transformation. You can run it from the *ThreadSafe* subdirectory with `ThreadSafe`. See also: [Performing a series of transformations](usagepatterns.md#performing-a-series-of-transformations). ## TraceListen What it does: Trace events during a transformation; the transformation uses *birds.xsl* to transform *birds.xml* and writes the output to *birds.out*. You can run it from the *TraceListen* subdirectory with: ```sh TraceListen traceFlags ``` where `traceFlags` is one or more of the following: * *-tt* (Trace the templates as they are being called) * *-tg* (Trace each result tree generation event) * *-ts* (Trace each selection event) * *-ttc* (Trace the template children as they are being processed) These flags are also available in the [command-line utility (TestXSLT)](commandline.md). The core of this example is the following fragment: ```c++ // Set up a diagnostic writer to be used by the TraceListener… 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 while another exception is active. // In particular, characters that the TraceListener writes might not be // representable in the local code page. theStdErr.setThrowTranscodeException(false); // Set up the TraceListener… // traceTemplates, traceTemplateChildren, traceGenerationEvent, // and TraceSelectionEvent are booleans set by the command line. TraceListenerDefault theTraceListener( diagnosticsWriter, traceTemplates, traceTemplateChildren, traceGenerationEvent, traceSelectionEvent); // Add the TraceListener to the XSLT processor… theProcessor.setTraceSelects(traceSelectionEvent); theProcessor.addTraceListener(&theTraceListener); // Perform the transformation … ``` ## TransformToXercesDOM What it does: Performs a simple transformation but puts the result in a Xerces `DOMDocument` Run this sample from the *TransformToXercesDOM* subdirectory with: ```sh TransformToXercesDOM XMLFile XSLFile ``` where *XMLFile* is a source XML file, and *XSLFile* is the XSLT input file. The program will use *XSLFile* to transform the input file *XMLFile* using Xerces DOM as the output destination. See the `FormatterToXercesDOM` usage in the sample code. ## UseStylesheetParam What it does: Performs a transformation using top-level stylesheet parameters. There are three supported types of parameters. One is a text string. A second is a number of type double. A nodeset or parsed document can also be used. You can run it from the *UseStylesheetParam* subdirectory with: ```sh UseStylesheetParam xmlfile stylesheet outfile [options] ``` where the options are: * *-s key "'String-Value'"* * *-n key Number* * *-d key "Document-URL"* The files used by the sample program and the top-level parameter nodesets for this illustration are to be in working directory in which the sample program runs. Using the sample program: ```sh UseStylesheetParam foo.xml foo.xslt foo.out \ -s stringA "'This is a test string value'" \ -n numberA 123.012345 \ -d parmA "parmA.xml" \ -d parmB "parmB.xml" ``` The `parmA.xml` and `parmB.xml` files are parsed and converted to nodesets. The stylesheet *foo.xslt* merges the contents of *foo.xml* and the parameters into the *foo.out* file. The source sample is implemented in C++. Another example is implemented in 'C' using the XalanCAPI library, *TestCAPIparm.c*. The usage interface for both is the same. See also: [Setting stylesheet parameters](usagepatterns.md#setting-stylesheet-parameters). ## XalanTransform What it does: `XalanTransform` uses the [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) class and the associated C++ API to apply an XSL stylesheet file to an XML document file and write the transformation output to either an output file or to a stream. `XalanTransform` takes command-line arguments for the XML document to be transformed, the XSL stylesheet to apply, and an optional output file argument. If you omit the third argument, `XalanTransform` writes the transformation output to a stream that is sent to standard out (the console). You can run `XalanTransform` from the *XalanTransform* subdirectory with: ```sh XalanTransform foo.xml foo.xsl foo.out ``` Omit the third argument to write the transformation result to the console. See also: [Using the XalanTransformer class](usagepatterns.md#performing-a-series-of-transformations). ## XalanTransformerCallback What it does: Return transformation output in blocks to a callback function, which writes the output to a file. This sample illustrates the use of a callback function to incrementally process a transformation result, that is to begin working with the transformation result before the transformation has been completed. See [Processing output incrementally](usagepatterns.md#processing-output-incrementally). You can run it from the *XalanTransformerCallback* subdirectory with: ```sh XalanTransformerCallback foo.xml foo.xsl [foo.out] ``` Note: If you omit the third argument, the transformation result is written to the console. xalan_c-1.12/docs/images/000755 001751 001751 00000000000 13667130245 016036 5ustar00rleighrleigh000000 000000 xalan_c-1.12/docs/usagepatterns.md000644 001751 001751 00000065264 13667130245 020015 0ustar00rleighrleigh000000 000000 # Xalan-C++ basic usage patterns ## Introduction To perform a transformation, use one of the [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4) methods. The transformation requires an XML source document and an XSL stylesheet. Both of these objects may be represented by instances of [`XSLTInputSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html). You can construct an `XSLTInputSource` with a [string](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#ab3f2b4a5da76309980d5c041ea19d285) (the system ID for a file or URI), an [input stream](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#a2acff554b429f9a60216cdf27eced1c4), or a [DOM](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#a96deb7a8eba28cb78cc6521f37fbdebb). If you are using an XSL stylesheet to perform a series of transformations, you can improve performance by calling [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#ad3ea23f954aaadd99a984da3a3c549aa) with a compiled stylesheet, an instance of [`XalanCompiledStylesheet`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanCompiledStylesheet.html). If you are transforming an XML source more than once, you should call [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#ad3ea23f954aaadd99a984da3a3c549aa) with a parsed XML source, an instance of [`XalanParsedSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanParsedSource.html). See [Performing a series of transformations](#performing-a-series-of-transformations) If you XML source document contains a stylesheet Processing Instruction (PI), you do not need to include a stylesheet object when you call [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a4adf2164af0f66831931ee104e383560). The transformation output is represented by an [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html), which you can set up to refer to an output stream, the system ID for a file or URI, or a Formatter for one of the various styles of DOM output. For detailed API documentation, see the Xalan-C++ API (doxygen). For an overview of the command-line utility, see [Command-Line Utility](commandline.md). ## Basic usage pattern with the XalanTransformer C++ API Using [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) and the C++ API, you can perform one or more transformations as described in the following steps. Note: For a working sample that illustrates these steps, see the [XalanTransform](samples.md#xalantransform) sample. ### 1. Include the required header files Always start with [*xalanc/Include/PlatformDefinitions.hpp*](https://apache.github.io/xalan-c/api/PlatformDefinitions_8hpp.html), the Xalan-C++ base header file. Also include *xercesc/util/PlatformUtils.hpp* and [*xalanc/XalanTransformer/XalanTransformer.hpp*](https://apache.github.io/xalan-c/api/XalanTransformer_8hpp.html), and any other header files your particular application requires. ```c++ #include #include #include … ``` ### 2. Define namespaces ```c++ using xercesc::XMLPlatformUtils; using xalanc::XalanTransformer; ``` Whilst you can use the standard C++ namespace syntax directly, the Xerces-C++ and Xalan-C++ namespaces are linked to the version number. For example, the Xalan namespace is currently `xalanc_1_12`. The macros will automatically take care of this when code is re-compiled against a new version of the libraries. Using the namespaces directly will require each namespace related statement be updated by hand. ### 3. Initialize Xerces and Xalan Use the static initializers to initialize the Xalan-C++ and Xerces-C++ platforms. You must initialize Xerces-C++ once per process. You may initialize and terminate Xalan-C++ multiple times, but this is not recommended: it is inefficient and is not thread safe. ```c++ XMLPlatformUtils::Initialize(); XalanTransformer::initialize(); ``` ### 4. Create a XalanTransformer ```c++ XalanTransformer theXalanTransformer; ``` ### 5. Perform each transformation You can explicitly instantiate [`XSLTInputSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html) objects for the XML source document and XSL stylesheet, and an [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html) object for the output, and then call [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4) with those objects as parameters. For example: ```c++ XSLTInputSource xmlIn("foo.xml"); XSLTInputSource xslIn("foo.xsl"); XSLTResultTarget xmlOut("foo-out.xml"); int theResult = theXalanTransformer.transform(xmlIn,xslIn,xmlOut) ``` Alternatively, you can call `transform()` with the strings (system identifiers), streams, and/or DOMs that the compiler needs to implicitly construct the `XSLTInputSource` and `XSLTResultTarget` objects. For example: ```c++ const char* xmlIn = "foo.xml"; const char* xslIn = "foo.xsl"; const char* xmlOut = "foo-out.xml"; int theResult = theXalanTransformer.transform(xmlIn,xslIn,xmlOut) ``` Keep in mind that [`XSLTInputSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html) and [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html) provide a variety of single-argument constructors that you can use in this manner: * [`XSLTInputSource(const char* systemID)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#ab3f2b4a5da76309980d5c041ea19d285) * [`XSLTInputSource(const XMLCh* systemID)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#a4f64b6ad613e97df373a08560edcbde0) (Unicode characters) * [`XSLTInputSource(istream* stream)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#a15252c4b7551019fde32c809a925a2e0) * [`XSLTInputSource(XalanNode* node)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html#a96deb7a8eba28cb78cc6521f37fbdebb) * [`XSLTResultTarget(char* fileName)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#a5ad1a1cc659c8b321acfdb088d2012d3) * [`XSLTResultTarget(XalanDOMString& fileName)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#a81dfd0938ce7f8b81512cba2fce5f9b2) * [`XSLTResultTarget(ostream* stream)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#aed57158ea3eabcc3dda8164b8f9afd38) * [`XSLTResultTarget(ostream& stream)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#a1dc8e4ec1b6817fcba5463292342e363) * [`XSLTResultTarget(Writer* characterStream)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#af1a6f0f49f60232ae5b57c839c35aca0) * [`XSLTResultTarget(FormatterListener& flistener)`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html#a931414334729593141383f5c26e0d50d) Note: Each `transform()` method returns an integer code, 0 for success. If an error occurs, you can use the [`getLastError()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a79d2edb51363413a1faa575d0e180c36) method to return a pointer to the error message. ### 6. Shut down Xalan When you shut down Xalan, you may also want to shut down Xerces and ICU support (if enabled). Keep the following considerations in mind: * Once you have shut down Xerces, you can no longer make Xalan or Xerces calls in the current process. * Shut down ICU support if you have enabled it, and if the application is exiting or no longer requires the ICU. The `XMLPlatformUtils::Terminate()` call does nothing if ICU support has not been enabled. * Ensure that there are no Xalan-C++ or Xerces-C++ objects extant at the point of termination. Any deletion of objects after termination could cause errors. Use the static terminators: ```c++ XalanTransformer::terminate(); XMLPlatformUtils::Terminate(); XalanTransformer::ICUCleanUp(); ``` ## Using a stylesheet processing instruction If you want to use the stylesheet referred to by a stylesheet processing instruction in the XML document, simply call `transform()` without the second `XSLTInputSource` argument. For example: ```c++ // foo.xml contains a stylesheet PI const char* xmlIn = "foo.xml"; const char* xmlOut = "foo-out.xml"; int theResult = theXalanTransformer.transform(xmlIn,xmlOut) ``` ## Setting Stylesheet Parameters An XSL stylesheet can include parameters that are set at run time before a transformation takes place. Traditionally, a top-level parameter value is of text string type. The Xalan library now supports three types of top-level parameters that can be set. One is a text string parameter. Another is a number parameter of floating point type double. The third is a nodeset (`XalanNode *`) parameter, usually implemented as a parsed document. Any XObject that is created outside of the transformation can be associated with a top-level parameter. The [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) has an XObject factory whereby top-level parameters can be owned by the `XalanTransformer` object. To set a stylesheet parameter, use the [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) [`setStylesheetParam()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a4d634fc758724facf8ac3b880a783cd1) method. The `setStylesheetParam()` method takes two arguments: the parameter name and the value. The value can be a string type, a number double type, an (`XalanNode *`) pointer to a nodeset or parsed document, or any XObjectPtr returned from an XObject factory. Top level parameters are sticky. Once set to an instance of an `XalanTransformer` object, they can be used for multiple transformations. The `XalanTransformer` `reset()` private method prepares a transformer for a new transformation. Use the [`clearStylesheetParams()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a40a4246572036efcb4b5d373229ecba1) method to release the top-level stylesheet parameters. The `Xalan` command line utility currently supports only a text string value for a top-level stylesheet parameter. The single quotes are required to identify a text string value. ```sh Xalan -p param1 "'string expression'"foo.xml foo.xsl ``` If the string expression includes spaces or other characters that the shell intercepts, first enclose the string in single quotes so Xalan-C++ interprets it as a string expression, and then enclose the resulting string in double quotes so the shell interprets it as a single argument. The [UseStylesheetParam](samples.md#usestylesheetparam) sample application supports all three types of top-level stylesheet parameters. The 'C' language interface [`XalanCAPI`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html) also supports the three types of top-level parameters. The sample program *TestCAPIparms.c* shows how to use top-level parameters with 'C' language programs. Note: The `Xalan` command line utility should be revised to accommodate the number and nodeset types of top-level stylesheet parameters. Only text string values are currently supported. Top-level stylesheet parameters of nodeset type (`XalanNode *`) are useful for the merging of multiple XML documents. ## Processing output incrementally [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) provides a [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a960ea8a2459658b8926db69d3b338814) method that sends the output in blocks to a callback function, which enables you to begin processing the output while the transformation is still in process: ```c++ int transform(const XSLTInputSource& xmlIn, const XSLTInputSource& xslIn, void* theOutputHandle, XalanOutputHandlerType theOutputHandler, XalanFlushHanderType theFlushHandler = 0); ``` For an example, see [XalanTransformerCallback](samples.md#xalantransformercallback). ### Performing a series of transformations Before Xalan performs a standard transformation, it must parse the XML document and compile the XSL stylesheet into binary representations. If you plan to use the same XML document or stylesheet in a series of transformations, you can improve performance by parsing the XML document or compiling the stylesheet once and using the binary representation when you call [`transform()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a3162d8129224a1a6ed67d8752f3447b4). [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) includes methods for creating compiled stylesheets and parsed XML documents: the [`compileStylesheet()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a9d31d4b43de86a6077f2df2a5a42c9d5) method returns a [`XalanCompiledStylesheet`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanCompiledStylesheet.html); the [`parseSource()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#ac03dba7386d874e22bf774ecb8dbd212) method returns a pointer [`XalanParsedSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanParsedSource.html). Note: In the case of failure, both methods return 0. Example using a [`XalanCompiledStylesheet`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanCompiledStylesheet.html) to perform multiple transformations: ```c++ XalanCompiledStylesheet* compiledStylesheet = 0; compiledStylesheet = theXalanTransformer.compileStylesheet("foo.xsl"); assert(compiledStylesheet!=0); theXalanTransformer.transform("foo1.xml", *compiledStylesheet, "foo1.out."); theXalanTransformer.transform("foo2.xml", *compiledStylesheet, "foo2.out"); … ``` For a working sample, see the [CompileStylesheet](samples.md#compilestylesheet) sample. Example using a [`XalanParsedSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanParsedSource.html) for multiple transformations: ```c++ XalanParsedSource* parsedXML = 0; parsedXML = theXalanTransformer.parseSource("foo.xml"); assert(parsedXML!=0); theXalanTransformer.transform(*parsedXML, "foo1.xsl", "foo-xsl1.out"); theXalanTransformer.transform(*parsedXML, "foo2.xsl", "foo-xsl2.out"); … ``` For a sample that uses both a parsed XML source and a compiled stylesheet, see [ThreadSafe](samples.md#threadsafe). ## Working with DOM input and output You can set up an [`XSLTResultTarget`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTResultTarget.html) to produce a DOM when you perform a transformation. You can also use a DOM as input for a transformation. The following code fragment illustrates the procedures for working with DOM output: ```c++ // Use the Xerces DOM parser to create a DOMDocument. #include #include #include #include using xercesc::DOMDocument; using xercesc::DOMImplementation; using xalanc::FormatterToXML; using xalanc::XalanTransformer; // If you want to produce DOM output, create an empty Xerces Document // to contain the transformation output. DOMDocument * theDOM = DOMImplementation::getImplementation()->createDocument(); // Now create a FormatterListener which can be used by the transformer // to send each output node to the new Xerces document FormatterToXercesDOM theFormatter(theDOM); // Now do the transform as normal XalanTransformer theXalanTransformer int theResult = theXalanTransformer.transform( "foo.xml", "foo.xsl", theFormatter); … // After you perform the transformation, the DOMDocument contains // the output. ``` Note: You can also follow the same process but use a [`FormatterToDeprecatedXercesDOM`](https://apache.github.io/xalan-c/api/classxalanc_1_1FormatterToDeprecatedXercesDOM.html) if you require a `DOM_Document` output. However this is discouraged, as support for the deprecated DOM may be removed in future releases of Xalan-C++. If you want to use a Xerces DOM object as input for a transformation without wrapping the DOM in a `XercesParserLiaison`, see [passing in a Xerces DOM](#passing-in-a-xerces-dom-to-a-transformation). ### Limitations Performance is much better when Xalan-C++ uses native source tree handling rather than interacting with the Xerces `DOMParser`. If you are using the deprecated DOM, the Xerces `DOMParser` by default, creates a `DOM_XMLDecNode` in the DOM tree to represent the XML declaration. The Xalan bridge for the Xerces DOM does not support this non-standard node type. Accordingly, you must call `DOMParser::setToCreateXMLDeclTypeNode(false)` *before* you parse the XML file. If not, the behavior is undefined, and your application may crash. ### Passing in a Xerces DOM to a transformation You may want to use a Xerces DOM that was created without using the [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) class. As the following code snippet illustrates, [`XercesDOMWrapperParsedSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XercesDOMWrapperParsedSource.html) to pass in a Xerces DOM as the source for an XSL transformation. ```c++ #include #include void parseWithXerces(XalanTransformer &xalan, const XSLTInputSource &xmlInput, const XalanCompiledStylesheet* styleSheet, const XSLTResultTarget &output, XMLFileReporter &logFile) { XercesDOMParser theParser; // Turn on validation and namespace support. theParser.setDoValidation(true); theParser.setDoNamespaces(true); // Parse the document theParser.parse(xmlInput); DOMDocument *theDOM = theParser.getDocument(); theDOM->normalize(); XercesDOMSupport theDOMSupport; XercesParserLiaison theParserLiaison; // Use the DOM to create a XercesDOMWrapperParsedSource, // which you can pass to the transform method. try { const XercesDOMWrapperParsedSource parsedSource( theDOM, theParserLiaison, theDOMSupport, XalanDOMString(xmlInput.getSystemId())); xalan.transform(parsedSource, stylesheet, output); } catch (…) { … } } ``` ## Working with XPath expressions XSL stylesheets use XPath expressions to select nodes, specify conditions, and generate text for the result tree. XPath provides an API that you can call directly. For example, you may want to select nodes programmatically and do your own processing without a stylesheet. Xalan-C++ provides an [`XPathEvaluator`](https://apache.github.io/xalan-c/api/classxalanc_1_1XPathEvaluator.html) interface to simplify the process of executing XPath expressions. For an example that executes XPath expressions against XML source files, see the [SimpleXPathAPI](samples.md#simplexpathapi) sample (which takes advantage of the `XPathEvaluator` interface) and the `XPathWrapper` sample. ## Using TraceListener [`TraceListener`](https://apache.github.io/xalan-c/api/classxalanc_1_1TraceListener.html) is a debugging abstract base class implemented by [`TraceListenerDefault`](https://apache.github.io/xalan-c/api/classxalanc_1_1TraceListenerDefault.html). You can use `TraceListener` to trace any combination of the following: * Calls to templates * Calls to template children * Selection events * Result tree generation events To construct a `TraceListener` with `TraceListenerDefault`, you need a [`PrintWriter`](https://apache.github.io/xalan-c/api/classxalanc_1_1PrintWriter.html) and a boolean for each of these four tracing options. You can then use the [`XSLTEngineImpl`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTEngineImpl.html) [`setTraceSelects()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTEngineImpl.html#a166e1275b28edc1102a1ec3cb83f7e70) and [`addTraceListener()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTEngineImpl.html#aaf85408a01bdd47b10f3e53e38f547a4) methods to add the `TraceListener` to an [`XSLTProcessor`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTProcessor.html). See the [TraceListen](samples.md#tracelisten) sample application. The `TraceListen` sample uses `TraceListenerDefault` to write events to the screen. ## Using the ICU You can use the [International Components for Unicode (ICU)](http://icu-project.org) to extend support for encoding, number formatting, and sorting. * *Encoding*. Xerces-C++ and Xalan-C++ use UTF-16 encoding to work with Unicode data. If you integrate the ICU with Xerces-C++, both Xerces-C++ and Xalan-C++ use ICU support for input and output transcoding. * *`format-number()`*. This XSLT function includes two or three arguments (the third is optional): number, format pattern, and decimal-format name. Xalan-C++ ignores the format pattern and optional decimal-format name. If you install ICU support for `format-number()`, this function is fully supported with all its arguments. * *`xsl:sort`*. If you install ICU support for `xml:sort`, Xalan-C++ implements Unicode-style collation. If you choose to build Xalan with ICU, you will need to rebuild Xerces with ICU as well. ### Enabling ICU support for encoding If you want to enable ICU support for encoding, you must enable ICU support in your Xerces-C++ build. Xerces-C++ uses ICU for input encoding. See the [Xerces-C++ build instructions](http://xerces.apache.org/xerces-c/build-3.html). With ICU support enabled in Xerces-C++, Xalan-C++ automatically uses ICU support for output encoding (the `xsl:output` encoding attribute). ### Enabling ICU support for number formatting and sorting If you only want to use the ICU to support number formatting and sorting, you do not need to enable ICU support in Xalan-C++, but you must do the following in the application where you want to enable ICU support: * Define the environment variable `ICUROOT`. * Substitute ICU support for `format-number()`, `xsl:number`, and/or `xsl:sort`. * Rebuild the Xalan-C++ library to include the [*ICUBridge*](https://apache.github.io/xalan-c/api/dir_2b905b8b39cf407945c0c5e85a4e6b9d.html). *ICUBridge* All Xalan-C++ references to ICU are centralized in the [*ICUBridge*](https://apache.github.io/xalan-c/api/dir_2b905b8b39cf407945c0c5e85a4e6b9d.html) module, which supplies the infrastructure for enabling ICU support for number formatting and sorting. ```c++ #include #include #include #include ``` Set the CMake option `transcoder=icu` when configuring to enable `ICUBridge`. *Number formatting* To enable ICU support for the XSLT `format-number()` function, do the following: ```c++ // Install ICU support for the format-number() function. FunctionICUFormatNumber::FunctionICUFormatNumberInstaller theInstaller; ``` *Sorting* To enable ICU support for `xsl:sort`, do the following: ```c++ // Set up a StylesheetExecutionContextDefaultobject // (named theExecutionContext in the following fragment), // and install the ICUCollationCompareFunctor. ICUBridgeCollationCompareFunctortheICUFunctor; theExecutionContext.installCollationCompareFunctor(&theICUFunctor); ``` ## Basic XalanTransformer usage pattern with the C API We also include a simple C interface for using the `XalanTransformer` class. The [ApacheModuleXSLT](samples.md#apachemodulexslt) sample illustrates the use of this C API. Basic strategy: ### 1. Include the XalanTransformer C API header ```c++ #include ``` ### 2. Initialize Xalan and Xerces ```c++ XalanInitialize(); ``` ### 3. Create a Xalan transformer ```c++ XalanHandle xalan = NULL; xalan = CreateXalanTransformer(); ``` ### 4. Perform each transformation For example: ```c++ const char * xmlfilename = "foo.xml"; const char* xslfilename = "foo.xsl"; const char* outfilename = "foo.out"; int theResult = 0; theResult = XalanTransformToFile(xmlfilename, xslfilename, outfilename, xalan); ``` Note: If the XML input file contains a stylesheet processing instruction that you want to use, use an empty [`XSLTInputSource`](https://apache.github.io/xalan-c/api/classxalanc_1_1XSLTInputSource.html) for the stylesheet argument. ### 5. Shut down Xalan ```c++ XalanTerminate(); ``` ## Variations with the XalanTransformer C API The Xalan C API supports approximately the same set of options as the C++ API. In particular, you can * Use stylesheet processing instructions (PI) to indicate the URI of the stylesheet. Supply `NULL` for the stylesheet argument. * Set stylesheet parameters. Use the [`SetStylesheetParam()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#af076f4ff44907f720bbfe859ae763271) function. * Compile stylesheets. Use the [`CompileStylesheet()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#a051cb11b9652d45700d46a07f2dfeb51) method to compile a stylesheet, and the [`TransformToFile()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#a7c4c4cb77cd7ea68b460d525b4d06dff) or [`TransformToData()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#ad2cf845c20c6b40ee1d558314a81de32) function to use the compiled stylesheet in a transformation. * Parse XML sources. Use the [`XalanParseSource()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#a9a376f062779b8e01bbaad16eaf826b4) method. * Place the transformation output in a character array. Use the [`TransformToData()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#ad2cf845c20c6b40ee1d558314a81de32) function. After you perform the transformation, use the [`XalanFreeData()`](https://apache.github.io/xalan-c/api/XalanCAPI_8h.html#a95ef1a205f372f95d320f53739417653) function to free memory allocated for the output data. * Send the output to a callback function to process blocks of output data as they arrive. For a sample that sends output in blocks to a callback function, see the [ApacheModuleXSLT](samples.md#apachemodulexslt) sample. xalan_c-1.12/docs/extensionslib.md000644 001751 001751 00000013450 13667130245 020004 0ustar00rleighrleigh000000 000000 # Xalan-C++ extensions library ## Introduction Extension functions provide a powerful mechanism for extending and simplifying what you can do with an XLST processor like Xalan. With input and contributions from the XML open-source developer community, we are working on placing the most useful extensions in an extensions library distributed with Xalan-C++. If you have ideas and/or contributions you would like to make, please email the Xalan Development Mailing List. ## EXSLT extensions Xalan-C++ supports the [EXSLT](http://exslt.org/) initiative to provide a set of standard extension functions to XSLT users. Xalan-C++ includes beta implementations for functions in four of the EXSLT namespaces (some are calls to extension already in the Xalan namespace). The source files for the implementations are in the XalanEXSLT subdirectory of the source tree. See * [*XalanEXSLTCommonImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTCommonImpl.hpp) * [*XalanEXSLTMathImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTMathImpl.hpp) * [*XalanEXSLTSetImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTSetImpl.hpp) * [*XalanEXSLTStringImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTStringImpl.hpp) * [*XalanEXSLTDynamicImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTDynamicImpl.hpp) * [*XalanEXSLTDateTimeImpl.hpp*](https://github.com/apache/xalan-c/blob/master/src/xalanc/XalanEXSLT/XalanEXSLTDateTimeImpl.hpp) For the function specifications, see: * [EXSLT common functions](http://www.exslt.org/exsl/exsl.html) * [EXSLT math functions](http://www.exslt.org/math/math.html) * [EXSLT set functions](http://www.exslt.org/set/set.html) * [EXSLT string functions](http://www.exslt.org/str/str.html) * [EXSLT dynamic functions](http://www.exslt.org/dyn/dyn.html) * [EXSLT date-time functions](http://www.exslt.org/date/date.html) Anyone who would like to participate in the Xalan-C++ initiative to support EXSLT by testing these implementations or implementing other EXSLT functions is more than welcome. Please email the Xalan Development Mailing List. ## Xalan namespace We are placing the Xalan extension functions in the `XalanExtensions` module and we have defined a namespace for this module: `http://xml.apache.org/xalan` If you are calling Xalan-C++-supplied extensions, we recommend that you define this namespace in your stylesheet element, and call the extension using the namespace prefix that you have associated with that namespace. That way, if we later reorganize how the Xalan-C++-supplied extensions are stored, you won't have to modify your stylesheet. For an example that uses this namespace, see [Example with the nodeset extension function](#example-with-the-nodeset-extension-function). ## nodeset Implemented in `FunctionNodeSet`, `nodeset (result-tree-fragment)` casts a result tree fragment into a `node-set`. Note: When you bind a variable to a template, rather than to the value generated by a select expression, the data type of the variable is result tree fragment. For more information, see [Result Tree Fragments](http://www.w3.org/TR/xslt#section-Result-Tree-Fragments). ### Example with the nodeset extension function The following stylesheet uses the `nodeset` extension function to cast a result tree fragment into a `node-set` that can then be navigated in standard XPath manner. It uses the `http://xml.apache.org/xalan` namespace to provide access to the `nodeset()` method in `xml.apache.xalan.lib.Extensions`. ```xml ELEMENT1A ,ELEMENT1B ELEMENT2A , ``` The output of running this stylesheet (with any XML input source) is a comma-delimited list of the element names in the `node-set` ```xml elem1,elem1a,elem1b,elem2,elem2a ``` Note: For illustration purposes, the preceding stylesheet pays no attention to the structure and content of the XML input document. Instead, it processes the template (in the stylesheet) bound to the variable named *rtf*. ## intersection Implemented in `FunctionIntersection`, `intersection (node-set1, node-set2)` returns a `node-set` with all nodes that are in *node-set1* and in *node-set2*. ## difference Implemented in `FunctionDifference`, `difference(node-set1, node-set2)` returns a `node-set` with the nodes in *node-set1* and not in *node-set2*. ## distinct Implemented in `FunctionDistinct`, `distinct (node-set)` returns a `node-set` containing nodes with distinct string values. If more than one node in the *node-set* contains the same text node value, distinct only returns the first of these nodes that it finds. ## evaluate Implemented in `FunctionEvaluate`, `evaluate (xpath-expression)` returns the result of evaluating the *xpath-expression* in the current XPath expression context (automatically passed in by the extension mechanism). Use the evaluation extension function when the value of the expression is not known until run time. ## hasSameNodes Implemented in `FunctionHasSameNodes`, `hasSameNodes(node-set1, node-set2)` returns true if both *node-set1* and *node-set2* contain exactly the same set of nodes. xalan_c-1.12/docs/extensions.md000644 001751 001751 00000024314 13667130245 017316 0ustar00rleighrleigh000000 000000 # Xalan-C++ extension functions ## Introduction At times, you may want to call your own custom C functions from a stylesheet. For these situations, Xalan-C++ supports the creation and use of extension functions. Xalan-C++ also provides a [library of extension functions](extensionslib.md) for your use. You can think of extension functions as extending the core library of functions that XPath provides. Like the XPath functions, an extension function returns an XObject, which may contain a value of any of the five XSLT data types: `node-set`, `result-tree-fragment`, `string`, `boolean` or `number`. You can send arguments to an extension function in the form of XPath expressions, literals (for `string`, `boolean`, and `number`), the values returned by other functions, and XSL variables or parameters set to any of the preceding. For an example that implements, installs, and uses three extension functions, see the [External Functions](samples.md#externalfunctions) sample. Note: Xalan-C++ does not support extension elements. ## Implementing an extension function Like the standard XPath functions, the functions you create derive from the Function base class. Set up your extension function class as follows: 1. The body of a function is the `execute()` method. Use the appropriate `XObjectFactory` method -- `createNumber()` in the example below -- to create an `XObject` corresponding to the XSLT data type the function returns. 2. Implement a `clone()` method to enable Xalan to create and maintain a copy of the extension function. 3. (Optional) As Xalan does for the XPath functions, you may want to prevent the compiler from generating an assignment or equality operator for this function. These features all appear in the following example. ```c++ // Base header file. Must be first. #include #include #include #include #include #include using namespace xalanc; // This class defines a function that will return the square root // of its argument. class FunctionSquareRoot : public Function { public: /** * Execute an XPath function object. The function must return a valid * XObject. * * @param executionContext executing context * @param context current context node * @param opPos current op position * @param args vector of pointers to XObject arguments * @return pointer to the result XObject */ virtual XObjectPtr execute( XPathExecutionContext& executionContext, XalanNode* /* context */, const XObjectPtr arg, const Locator* /* locator */) const { if (args.size() != 1) { executionContext.error("The square-root() function takes one argument!", context); } assert(args[0] != 0); // Use the XObjectFactory createNumber() method to create an XObject // corresponding to the XSLT number data type. return executionContext.getXObjectFactory().createNumber( sqrt(args[0]->num())); } /** * Implement clone() so Xalan can copy the square-root function into * its own function table. * * @return pointer to the new object */ virtual FunctionSquareRoot* clone() const { return new FunctionSquareRoot(*this); } private: // The assignment and equality operators are not implemented… FunctionSquareRoot& operator=(const FunctionSquareRoot&); bool operator==(const FunctionSquareRoot&) const; } ``` ## Installing an extension function [`XalanTransformer`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html) provides methods for installing and uninstalling external functions: * [`installExternalFunction()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a7d932d74897e12629afd62bba2735456) makes the function available in the current instance of `XalanTransformer`. Use [`uninstallExternalFunction()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a8dbb4538357ab2909925dd16a449dbac) to remove the function. * [`installExternalFunctionGlobal()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#a7d4f49b03739feaa01cdbffd5668e736) makes the function available globally. Use [`uninstallExternalFunctionGlobal()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanTransformer.html#ab5c8f39bcf0bf84b6bbe0607bbe4afde) to remove the function. The global install and uninstall operations are not thread-safe. However, all global functions should be thread-safe, because multiple threads could call a particular function instance at the same time. These methods include arguments for the namespace, the function name, and the function implementation. When you install an extension function, the function inhabits the namespace you designate. For information about XML namespaces, see [Namespaces in XML](http://www.w3.org/TR/REC-xml-names/). The following code fragment installs locally the square root function defined above, and binds it to the extension-function name `square-root` in the namespace `http://MyExternalFunction.mycompany.org` so it can be accessed from stylesheets. Keep in mind that the function name does not need to be the same as the name of the function class, and that a function name may be used more than once provided that each function with that name is installed in a different namespace. ```c++ #include #include // You have created a header file for FunctionSquareRoot. #include // The namespace… const XalanDOMString theNamespace("http://MyExternalFunction.mycompany.org"); theXalanTransformer.installExternalFunction(theNamespace, XalanDOMString("square-root"), FunctionSquareRoot()); ``` For an example that installs three functions, see the [External Functions](samples.md#externalfunctions) sample. ## Using an extension function To use the extension function in a stylesheet, you must do the following: 1. Declare the extension function namespace.
`xmlns:prefix=URI`
The `prefix` identifies the namespace, and `URI` matches the namespace specified when the function is installed.
By default, namespace declarations are included in the transformation output. To exclude namespaces from the output, use
`exclude-result-prefixes="prefix-1 prefix-2 …"`
in the stylesheet element or
`xsl:exclude-result-prefixes="prefix-1 prefix-2 …"`
in a literal result element or extension element. 2. Call the extension function in the same manner you would call an XPath function. The function name you use in the stylesheet is a Qualified Name (QName) made up of the prefix you declared in step 1 and the function name you specified when you installed the function.
You can use XPath expressions, literals (for `string`, `boolean`, and `number`), and values returned by other functions to specify function arguments. Suppose, for example, you are working with XML documents containing area elements like ``, where the value attribute identifies the area of a square. The following stylesheet declares the square-root function namespace (the prefix is up to you), instructs the processor not to copy the namespace declaration to the result tree, and uses the square-root function to return the square root of `//area/@value:` ```xml The area of the square is square units. The length of each side is units ``` This stylesheet converts `` into the following output: ```xml The area of the square is 397 square units. The length of each side is 19.9249 units. ``` For a slightly more complex variation on this example, see the [External Functions](samples.md#externalfunctions) sample ### Passing Nodes to a function Please keep in mind that *all* `LocationPath` expressions return a `node-set`, even if the expression only returns a single attribute or a `text` node (`node-set`s with one member). You can use the XSLT `string()` function to convert a `node-set` value to `string`, and the `number()` function to convert a `node-set` value to `number` (a double). If you pass a `node-set` to an extension function, be sure to set up the function to process a node-set. Suppose, for example, you have a `ProcessNodes` function class that uses ```c++ const NodeRefListBase& theNodeList = args[0]->nodeset(); ``` in the `execute()` method to get a reference to the `node-set`. Assuming you install the function as `ProcessNodes` and use the `node-ext` prefix in a stylesheet to refer to the `ProcessNodes` function namespace, any of the following function calls are syntactically possible: ```xml ``` The `NodeRefListBase` is in fact a list of references into the XML document, so keep in mind that [`getNextSibling()`](https://apache.github.io/xalan-c/api/classxalanc_1_1XalanNode.html#a9b4a7333371ffee9a6fd851203f4c98a), for example, gets you the next sibling in the document, which may not be the next `Node` in the `node-set`. xalan_c-1.12/docs/build.md000644 001751 001751 00000016324 13667130245 016220 0ustar00rleighrleigh000000 000000 # Building Xalan-C++ ## Overview The build process is divided into several parts: configuration and building, followed by (optional) testing and installation. The configuration part is performed with CMake. The build part is performed by invoking the chosen build tool such as `make` or `ninja`, or by opening the generated project files in your IDE, and building from within the IDE. ## Prerequisites The following are required before building Xalan-C++ * A C++ compiler such as GCC, LLVM or MSVC (provided with Microsoft Visual Studio) * CMake * Chosen build tool and/or IDE * Xalan-C++ sources (see [Downloading Xalan-C++](download.md)) * Xerces-C++ library and headers * ICU C++ libraries and headers (optional) Xalan-C++ uses the [CMake](https://cmake.org/) build generator and requires that be installed. Additionally, a build tool such as [GNU make](http://www.gnu.org/software/make/make.html) or [Ninja](https://ninja-build.org/) is required for building. CMake supports a wide range of generators for several different compilers, build tools and popular IDEs, including Eclipse, Kate, Visual Studio, Sublime Text and more. Any of these may be used to build Xalan-C++. Run `cmake --help` to display the full list of supported generators for your platform. Xalan-C++ is built upon the Xerces-C++ XML Parser library. You can either install a compatible binary distribution of Xerces-C/C++ or build your own from a source distribution of Xerces-C/C++. You can get more information on the Xerces-C/C++ distributions at the [Xerces-C++ website](http://xerces.apache.org/xerces-c). If you want to take advantage of the support for number formatting, sorting, and encoding the ICU provides, you should also download and install the [International Components for Unicode (ICU)](http://icu-project.org); see [Using the ICU](usagepatterns.md#using-the-icu). ## Configuration Besides the standard CMake [variables](https://cmake.org/cmake/help/latest/manual/cmake-variables.7.html), Xalan-C++ provides a number of project-specific options. You can specify one option for each category outlined below. If you do not specify anything for a particular category then CMake will select the most appropriate default, based upon the available options for your system. At the end of its execution, CMake prints the selected values for each category. Transcoder (used to convert between internal UTF-16 and other encodings): |Option|Description| |---|---| |`-Dtranscoder=default`|use built-in transcoder (default)| |`-Dtranscoder=icu`|use the ICU library| Message Loader (used to access diagnostics messages): |Option|Description| |---|---| |`-Dmessage-loader=inmemory`|store the messages in memory (default)| |`-Dmessage-loader=icu-broken`|store the messages using the ICU resource bundles (broken, do not use)| |`-Dmessage-loader=nls-broken`|store the messages in the NLS message catalog using catopen/catgets (broken, do not use)| System character-set encoding: |Option|Description| |---|---| |`-Dsystem-encoding=ascii`|use ASCII system encoding (default for most platforms)| |`-Dsystem-encoding=ebcdic`|use EBCDIC system encoding (default for OS390)| Thread support is required and can not be disabled. Shared libraries are built by default. You can use the `-DBUILD_SHARED_LIBS:BOOL=OFF` option to build static libraries. If you need to specify compiler executables that should be used to build Xalan-C++, you can set the `CC` and `CXX` environment variables when invoking `cmake`. Similarly, if you need to specify additional compiler or linker options, you can set the `CFLAGS`, `CXXFLAGS`, and `LDFLAGS` environment variables. For example: ``` CC=gcc-8.4 CXX=g++-8.4 CFLAGS=-O3 CXXFLAGS=-O3 cmake … ``` If building on Windows, the specific Visual Studio version may be selected with some generators, and this may be run from a normal command prompt. If using a generic generator such as `Ninja`, then `cmake` should be run from a Visual Studio command prompt, or in a suitably configured environment, so that the correct compiler will be detected. ## Building Once the configuration part is complete you can run the build tool of choice. This may be done generically using `cmake --build . [--config=Debug|Release]`. Alternatively, a specific build tool, e.g. `make`, `gmake`, `ninja` or `msbuild` corresponding to the chosen generator may be used directly. When invoked without a specific target, it will build the Xalan-C++ library, all examples and all unit tests. ## Testing If you would like to run the automated test suite, run `ctest [-V] [-C Debug|Release]`. This will run all tests. Additional [options](https://cmake.org/cmake/help/latest/manual/ctest.1.html) are available, such as running a subset of the tests and running the tests in parallel. ## Installation Finally, install the library and examples. This may be done generically using `cmake --build . --target install [--config=Debug|Release]`. Alternatively, a specific build tool may be used, e.g. `make install`. To change the installation directory, use the `-DCMAKE_INSTALL_PREFIX=prefix` CMake option. ## Additional notes ### Extra CMake options Some platforms and configurations may require extra `cmake` options. Run `cmake -LH` to list the additional options, along with a short description for each. For each of the selection categories mentioned above, the help text will list the valid choices detected for your platform. Run `cmake -LAH` for all the additional advanced settings. ### Shared libraries Note that different UNIX platforms use different system environment variables for finding shared libraries. On Linux and Solaris, the environment variable name is `LD_LIBRARY_PATH`, on AIX it is `LIBPATH`, on Mac OS X it is `DYLD_FALLBACK_LIBRARY_PATH`, and on HP-UX it is `SHLIB_PATH`. Note that Windows (including Cygwin and MinGW), is different from the UNIX platforms in the way it finds shared libraries at run time. While UNIX platforms may use the `LD_LIBRARY_PATH` environment variable, Windows uses the `PATH` environment variable if the library is not in the same directory as the executable. ## Examples Several examples of configuring, building, testing and installing with CMake using different platforms, generators, and installation options are shown below: ### Ninja generator (any platform) ```sh mkdir build cd build cmake -G Ninja -DCMAKE_INSTALL_PREFIX=/opt/Xalan-c -DCMAKE_BUILD_TYPE=Release -Dnetwork-accessor=curl /path/to/Xalan-c/source ninja ctest -V -j 8 ninja install ``` ### Unix Makefiles generator (UNIX) ```sh mkdir build cd build cmake -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX=/opt/Xalan-c -DCMAKE_BUILD_TYPE=Debug -Dmessage-loader=icu /path/to/Xalan-c/source make -j8 make test make install ``` ### MSBuild with Visual Studio 2017 (Windows) In a command shell: ```sh mkdir build cd build cmake -G "Visual Studio 15 2017 Win64" -DCMAKE_INSTALL_PREFIX:PATH=D:\xalan-c \path\to\Xalan-c\source cmake --build . --config Debug ctest -V -C Debug -j 4 cmake --build . --config Debug --target install ``` ### Ninja with Visual Studio 2019 and vcpkg (Windows) At a Visual Studio 2019 command prompt: ```sh mkdir build cd build cmake -G Ninja -DCMAKE_TOOLCHAIN_FILE:PATH=D:\vcpkg\scripts\buildsystems\vcpkg.cmake -DCMAKE_INSTALL_PREFIX:PATH=D:\xalan-c \path\to\Xalan-c\source ninja ctest -V -j 4 ninja install ``` xalan_c-1.12/docs/doxygen/000755 001751 001751 00000000000 13667130245 016246 5ustar00rleighrleigh000000 000000 xalan_c-1.12/docs/releases.md000644 001751 001751 00000077274 13667130245 016737 0ustar00rleighrleigh000000 000000 # Xalan-C++ Release History # 1.12 Released on the 7th June 2020. ## Major changes The focus of this release is stability and compatibility. The majority of changes are bugfixes or portability improvements. * Xerces-C++ versions 3.0 and newer are supported. Xerces-C++ Version 3.2.3 is the preferred stable release. * Addition of a CMake build for all supported platforms. * Rewrite of StyleBook XML documentation in Markdown, hosted at [https://apache.github.io/xalan-c/](https://apache.github.io/xalan-c/). * Removal of MacOS and Windows project files for old IDE versions. * Removal of Autoconf build. * Xalan-C++ now supports Microsoft Visual Studio 2019 and earlier via the new CMake build, which replaces the old version-specific project and solution files. * Xalan-C++ now also supports building with C++11, C++14 and C++17. * Cygwin and MinGW are known to be nonfunctional in this release. Restoring full support will be a goal for 1.13. ## Issues resolved ### Bug * [XALANC-751](https://issues.apache.org/jira/browse/XALANC-751): Segmentation fault in TestXSLT * [XALANC-773](https://issues.apache.org/jira/browse/XALANC-773): Build failure with Xerces-C++ 3.2.0 and VS2015 * [XALANC-787](https://issues.apache.org/jira/browse/XALANC-787): Drop MacOS and Windows project files * [XALANC-788](https://issues.apache.org/jira/browse/XALANC-788): Drop Autoconf build * [XALANC-789](https://issues.apache.org/jira/browse/XALANC-789): Check CMake build correctly versions libraries on all platforms * [XALANC-790](https://issues.apache.org/jira/browse/XALANC-790): Ensure CMake is using the library rc files for both libraries * [XALANC-792](https://issues.apache.org/jira/browse/XALANC-792): Replace StyleBook documentation with a supported equivalent * [XALANC-793](https://issues.apache.org/jira/browse/XALANC-793): CMake build should install pkg-config file * [XALANC-794](https://issues.apache.org/jira/browse/XALANC-794): XalanTransform does not transform anything * [XALANC-795](https://issues.apache.org/jira/browse/XALANC-795): CMake CTest should run all samples as well as unit tests * [XALANC-797](https://issues.apache.org/jira/browse/XALANC-797): Generate XalanVersion.hpp * [XALANC-798](https://issues.apache.org/jira/browse/XALANC-798): Remove use of version.incl * [XALANC-799](https://issues.apache.org/jira/browse/XALANC-799): Remove use of winres.h in XalanMsgLib.rc * [XALANC-800](https://issues.apache.org/jira/browse/XALANC-800): Add CMake feature tests to replace specific platform definitions * [XALANC-801](https://issues.apache.org/jira/browse/XALANC-801): Enable AppVeyor CI for Windows * [XALANC-805](https://issues.apache.org/jira/browse/XALANC-805): Apply outstanding critical fixes * [XALANC-806](https://issues.apache.org/jira/browse/XALANC-806): C++98 and C++11 support * [XALANC-807](https://issues.apache.org/jira/browse/XALANC-807): CMake build unconditionally adds debug postfix with MSVC ### Improvement * [XALANC-776](https://issues.apache.org/jira/browse/XALANC-776): Add CMake build system * [XALANC-777](https://issues.apache.org/jira/browse/XALANC-777): Remove redundant XALAN_SGI_BASED_STL macro * [XALANC-778](https://issues.apache.org/jira/browse/XALANC-778): Use anonymous namespace for private time compatibility functions * [XALANC-779](https://issues.apache.org/jira/browse/XALANC-779): Use xercesc namespace unconditionally * [XALANC-780](https://issues.apache.org/jira/browse/XALANC-780): Use xalanc namespace unconditionally ### Wish * [XALANC-771](https://issues.apache.org/jira/browse/XALANC-771): Support for Parallel Builds # 1.11 This is primarily a bug-fix release of version 1.10. Support for number and nodeset types for stylesheet top-level parameters have been added. Xerces-C++ versions 3.0 and newer are now supported. Xerces-C++ Version 3.1.1 is the preferred stable release. ## Major changes * Add support for Xerces-C 3.0 and newer * Drop support for Microsoft Studio (VC6) * Microsoft Visual Studio .NET platforms (2003, 2005, 2008, and 2010) are supported. This equates to compilers (VC71, VC8, VC9, and VC10). * Fix support issues for AIX 5.3 * Fix support issues for Solaris 2.8 * Fix support issues for Solaris 2.10 * Fix support issues for GCC-4.3 * Add support for Microsoft .NET 2008 (VC9) * Add support for Microsoft .NET 2010 (VC10) * Add number and nodeset types as top-level stylesheet parameters * Allow separation of compiler CFLAGS and CXXFLAGS for UNIX builds * Xalan-C documentation rewrite and reorganize * Parent Apache XML Project has been retired ## Bug fixes * [XALANC-734](https://issues.apache.org/jira/browse/XALANC-734): Allow runConfigure CFLAGS and CXXFLAGS to inherit environment * [XALANC-732](https://issues.apache.org/jira/browse/XALANC-732): Fix makefile errors for AIX builds * [XALANC-730](https://issues.apache.org/jira/browse/XALANC-730): Fixed XalanTransformer memory leaks * [XALANC-723](https://issues.apache.org/jira/browse/XALANC-723): Add Top-Level parameter support for XalanCAPI and UseStylesheetParams samples * [XALANC-723](https://issues.apache.org/jira/browse/XALANC-723): The XalanTransformer Top-Level parameters now include nodeset and number types * [XALANC-721](https://issues.apache.org/jira/browse/XALANC-721): Upgrade support for MS VS 2010 (VC10) * [XALANC-719](https://issues.apache.org/jira/browse/XALANC-719): Xerces Parser Liaison - errors on elements with no attributes * [XALANC-716](https://issues.apache.org/jira/browse/XALANC-716): incorrect buffer-size calculation in XalanUTF16Writer.hpp * [XALANC-715](https://issues.apache.org/jira/browse/XALANC-715): NULL pointer access crash * [XALANC-713](https://issues.apache.org/jira/browse/XALANC-713): Build Xalan-C++ API Reference Manual using Doxygen 1.7 or newer * [XALANC-712](https://issues.apache.org/jira/browse/XALANC-712): Rewrite of Xalan-C++ V1.11 User Guide Web Pages * [XALANC-710](https://issues.apache.org/jira/browse/XALANC-710): MS-Studio 2008 Debug Build sends Xalan-C_1D.lib to wrong directory * [XALANC-709](https://issues.apache.org/jira/browse/XALANC-709): Doxygen bug in XalanQName.hpp * [XALANC-708](https://issues.apache.org/jira/browse/XALANC-708): Including XalanCAPI.hpp does not import Xerces typedef XMLch * [XALANC-705](https://issues.apache.org/jira/browse/XALANC-705): Crash with pure virtual function call * [XALANC-703](https://issues.apache.org/jira/browse/XALANC-703): Compiler errors while building on AIX 5.3 * [XALANC-700](https://issues.apache.org/jira/browse/XALANC-700): Broken output when serializing UTF16 surrogates * [XALANC-699](https://issues.apache.org/jira/browse/XALANC-699): Compile using Visual C++ 2010 (VC10) * [XALANC-698](https://issues.apache.org/jira/browse/XALANC-698): Buffer overflow from XalanMessageLoader::load() * [XALANC-690](https://issues.apache.org/jira/browse/XALANC-690): The document function does not handle fragment IDs in URLs correctly * [XALANC-689](https://issues.apache.org/jira/browse/XALANC-689): XalanC transformation of a 600 kb file takes 43 seconds * [XALANC-684](https://issues.apache.org/jira/browse/XALANC-684): XPath single quate-comma bug * [XALANC-683](https://issues.apache.org/jira/browse/XALANC-683): xsl:number with level any does not always count all of the preceeding nodes in the document * [XALANC-681](https://issues.apache.org/jira/browse/XALANC-681): NamedNodeMapAttributeList constructor asserts when the provided NamedNodeMap is empty * [XALANC-680](https://issues.apache.org/jira/browse/XALANC-680): Error in match pattern with // and abbreviated attribute node test * [XALANC-679](https://issues.apache.org/jira/browse/XALANC-679): Possible wrong evaluation of abbreviated XPath in template match * [XALANC-677](https://issues.apache.org/jira/browse/XALANC-677): Debug assertion switching to HTML mode when the outputter is producing a DOM * [XALANC-675](https://issues.apache.org/jira/browse/XALANC-675): No error is reported for an unknown key * [XALANC-675](https://issues.apache.org/jira/browse/XALANC-675): GCC-4.3 cleanup * [XALANC-673](https://issues.apache.org/jira/browse/XALANC-673): Assertion failed with XalanDOMString::substr * [XALANC-671](https://issues.apache.org/jira/browse/XALANC-671): Incorrect handling of default namespace in xsl:element * [XALANC-669](https://issues.apache.org/jira/browse/XALANC-669): XalanOtherEncodingWriter reports an incorrect error message * [XALANC-667](https://issues.apache.org/jira/browse/XALANC-667): setUseValidation doesn't work * [XALANC-664](https://issues.apache.org/jira/browse/XALANC-664): Testing harness writes strings to the output XML in the local code page. * [XALANC-661](https://issues.apache.org/jira/browse/XALANC-661): PlatformSupport/DoubleSupport.cpp compile error on AIX 5.3 * [XALANC-660](https://issues.apache.org/jira/browse/XALANC-660): Compilation errors in Tests/Performance/TestHarness.hpp on some platforms * [XALANC-659](https://issues.apache.org/jira/browse/XALANC-659): Unnecessary casting in ReusableArenaBlock * [XALANC-658](https://issues.apache.org/jira/browse/XALANC-658): Misplaced assert in ReusableArenaAllocator::destroyObject() * [XALANC-657](https://issues.apache.org/jira/browse/XALANC-657): Add Windows x64 targets to the project files * [XALANC-655](https://issues.apache.org/jira/browse/XALANC-655): Boolean value incorrectly converted ot string in attribute value templates * [XALANC-653](https://issues.apache.org/jira/browse/XALANC-653): Xalan-C not including namespace declaration in output * [XALANC-650](https://issues.apache.org/jira/browse/XALANC-650): XPathProcessorImpl uses XalanDOMString copy constructor instead of referring to an existing instance * [XALANC-648](https://issues.apache.org/jira/browse/XALANC-648): XalanUTF8Writer::write(const XalanDOMChar*, XalanDOMString::size_type) does not handle surrogates properly * [XALANC-647](https://issues.apache.org/jira/browse/XALANC-647): XalanOtherEncodingWriter::writeNumericCharacterReference() is inefficient * [XALANC-646](https://issues.apache.org/jira/browse/XALANC-646): During transcoding XalanC fails to append '0' to the transcoded string * [XALANC-645](https://issues.apache.org/jira/browse/XALANC-645): Pluggin of DOMStringPrintWriter into FormatterToXML leads to assert * [XALANC-641](https://issues.apache.org/jira/browse/XALANC-641): Class used as exception needs accessible copy constructor * [XALANC-640](https://issues.apache.org/jira/browse/XALANC-640): Path problem in Makefile under cygwin * [XALANC-638](https://issues.apache.org/jira/browse/XALANC-638): Performance test program does not build on HP-UX * [XALANC-635](https://issues.apache.org/jira/browse/XALANC-635): Build fails on Solaris 2.8 * [XALANC-634](https://issues.apache.org/jira/browse/XALANC-634): Build fails with VC6 * [XALANC-633](https://issues.apache.org/jira/browse/XALANC-633): The processor should ignore xsl:fallback element in LRE * [XALANC-632](https://issues.apache.org/jira/browse/XALANC-632): @use-attribute-sets attribute has to have no effect on xsl:copy when the context item is a documen node. * [XALANC-631](https://issues.apache.org/jira/browse/XALANC-631): The next stylesheet crashes XalanC * [XALANC-630](https://issues.apache.org/jira/browse/XALANC-630): Incorrect cast in XalanUTF16Writer * [XALANC-629](https://issues.apache.org/jira/browse/XALANC-629): Performance improvements for text node stripping * [XALANC-628](https://issues.apache.org/jira/browse/XALANC-628): Inconsistent flusing of serializers * [XALANC-627](https://issues.apache.org/jira/browse/XALANC-627): Broken cast in ElemTemplateElement::findTemplateToTransformChild() * [XALANC-626](https://issues.apache.org/jira/browse/XALANC-626): Fix copyrights in Apache XalanC source * [XALANC-625](https://issues.apache.org/jira/browse/XALANC-625): Spurious (though harmless) assert failure in XPath::findNodeSet() when an expression contains an empty node-set enclosed in parenthesis * [XALANC-624](https://issues.apache.org/jira/browse/XALANC-624): The key() function does not work when the context node is the root node of a result tree fragment obtained through exsl:node-set() * [XALANC-623](https://issues.apache.org/jira/browse/XALANC-623): Compatibility issues with Xerces-C 3.0 * [XALANC-621](https://issues.apache.org/jira/browse/XALANC-621): Selection of compiler definitions file fails on Linux PPC in client code * [XALANC-618](https://issues.apache.org/jira/browse/XALANC-618): uninstallExternalFunction can run past the end of the array * [XALANC-617](https://issues.apache.org/jira/browse/XALANC-617): Leak in XalanTransformer * [XALANC-616](https://issues.apache.org/jira/browse/XALANC-616): xsl:strip-space element doesn't work proprely * [XALANC-615](https://issues.apache.org/jira/browse/XALANC-615): Xalan resolves a namespace prefix when it should report an error * [XALANC-614](https://issues.apache.org/jira/browse/XALANC-614): MsgCreator Makefile needs link option * [XALANC-613](https://issues.apache.org/jira/browse/XALANC-613): Cannot pass value to stylesheet parameter if parameter name is namespace-qualified * [XALANC-609](https://issues.apache.org/jira/browse/XALANC-609): Template with built-in template rules for namespaces gives and assert * [XALANC-604](https://issues.apache.org/jira/browse/XALANC-604): ConstructWithNoMemoryManager has a bug which prevents proper default initialization of built-in types. * [XALANC-603](https://issues.apache.org/jira/browse/XALANC-603): Source does not compile properly on HP-UX with newer versions of the HP compiler * [XALANC-595](https://issues.apache.org/jira/browse/XALANC-595): EXSLT date-time function missing + or - before timezone offset * [XALANC-588](https://issues.apache.org/jira/browse/XALANC-588): Floating point exceptions in DoubleSupport::initialize() on Solaris 10 (x86) * [XALANC-570](https://issues.apache.org/jira/browse/XALANC-570): Removal of compiler warnings from STLHelper.hpp * [XALANC-535](https://issues.apache.org/jira/browse/XALANC-535): If an error/warning message contains not-displayable character for the local encoding , no message is shown at all * [XALANC-527](https://issues.apache.org/jira/browse/XALANC-527): Compiling on Xerces-3.0 * [XALANC-480](https://issues.apache.org/jira/browse/XALANC-480): XML1.1 and Namespaces for XML1.1 support * [XALANC-478](https://issues.apache.org/jira/browse/XALANC-478): Add support for XMLEntityResolver * [XALANC-432](https://issues.apache.org/jira/browse/XALANC-432): Minor spelling problems in XalanMsg_en_US.xlf * [XALANC-430](https://issues.apache.org/jira/browse/XALANC-430): "StylesheetExecutionContext::getVariable(name)" crahes if variable "name" was not found. * [XALANC-421](https://issues.apache.org/jira/browse/XALANC-421): omit-xml-declaration ignored * [XALANC-416](https://issues.apache.org/jira/browse/XALANC-416): Wrong access to out-of-scope xsl:variable not detected in certain circumstances * [XALANC-415](https://issues.apache.org/jira/browse/XALANC-415): Encoding attribute is not returning properly in output XML header * [XALANC-413](https://issues.apache.org/jira/browse/XALANC-413): Crash while using transform method on MacOSX * [XALANC-412](https://issues.apache.org/jira/browse/XALANC-412): XalanEXSLTDateTime not threadsafe, crashing application * [XALANC-409](https://issues.apache.org/jira/browse/XALANC-409): compilation error on g++ on SunOS 2.8 * [XALANC-408](https://issues.apache.org/jira/browse/XALANC-408): runConfigure help does not include new HP platform * [XALANC-407](https://issues.apache.org/jira/browse/XALANC-407): XalanC output format is not suitable as a document entity * [XALANC-376](https://issues.apache.org/jira/browse/XALANC-376): Result tree fragment attributes are created without proper namespace and local name # 1.10 ## Major changes * Support for XML 1.1 and Namespaces in XML 1.1. * Added support for IBM XLC 7.0 compiler on AIX. * Improved and stabilized C pluggable memory management functionality. * Various improvements in Xalan XML serializers for better performance and stability. * Upgrade from Xerces-C 2.6 to Xerces-C 2.7. ## Bug fixes * [XALANC-572](https://issues.apache.org/jira/browse/XALANC-572): Compile failure on SuSE80AMD_64b_GCC322 * [XALANC-569](https://issues.apache.org/jira/browse/XALANC-569): Compile-time assert on 32-bit Solaris and HPUX due to IEEE754 issue * [XALANC-568](https://issues.apache.org/jira/browse/XALANC-568): Pattern "/" does not match the pseudo root document of a node-set obtained from a result-tree fragment via exsl:node-set * [XALANC-511](https://issues.apache.org/jira/browse/XALANC-511): Crash during XalanTransformer::initialize on AIX * [XALANC-554](https://issues.apache.org/jira/browse/XALANC-554): Xalan-C does not implement erratum 25 * [XALANC-552](https://issues.apache.org/jira/browse/XALANC-552): Problems with the new serializers with CDATA and unrepresentable or special characters * [XALANC-558](https://issues.apache.org/jira/browse/XALANC-558): Latest source code does not build with the Intel compiler on Windows * [XALANC-555](https://issues.apache.org/jira/browse/XALANC-555): XalanEXSLTDateTime.cpp has too many platform-specifc ifdefs * [XALANC-421](https://issues.apache.org/jira/browse/XALANC-421): omit-xml-declaration ignored * [XALANC-529](https://issues.apache.org/jira/browse/XALANC-529): Xalan-C sometimes creates empty text nodes in RTFs or sends empty characters() events to FormatterListeners * [XALANC-530](https://issues.apache.org/jira/browse/XALANC-530): Serializers filter attributes unnecessarily * [XALANC-245](https://issues.apache.org/jira/browse/XALANC-245): substring-before and substring-after * [XALANC-115](https://issues.apache.org/jira/browse/XALANC-115): Need to catch use of variables in xsl:key attributes * [XALANC-540](https://issues.apache.org/jira/browse/XALANC-540): XPath absolute location path does not work when the context node was obtained from a result tree fragment through exsl:node-set() * [XALANC-544](https://issues.apache.org/jira/browse/XALANC-544): Assert failure, then crash, during "variable undefined" error recovery in certain circumstances. * [XALANC-543](https://issues.apache.org/jira/browse/XALANC-543): Crash when calling a template that wrongly uses xsl:with-param instead of xsl:param to declare its parameter. * [XALANC-539](https://issues.apache.org/jira/browse/XALANC-539): XalanMap needs to compact buckets to prevent long search times and ever-increasing memory usage. * [XALANC-542](https://issues.apache.org/jira/browse/XALANC-542): XalanDocumentFragmentXNodeSetBaseProxy::dereferenced() is not implemented properly * [XALANC-538](https://issues.apache.org/jira/browse/XALANC-538): Better handling for non-existent node test * [XALANC-541](https://issues.apache.org/jira/browse/XALANC-541): Fixes for zOS build * [XALANC-455](https://issues.apache.org/jira/browse/XALANC-455): Problem when releasing InputSource obtained through an EntityResolver * [XALANC-535](https://issues.apache.org/jira/browse/XALANC-535): If an error/warning message contains not-displayable character for the local encoding , no message is shown at all * [XALANC-532](https://issues.apache.org/jira/browse/XALANC-532): FormatterToXMLUnicode does not serialize UTF-8 * [XALANC-536](https://issues.apache.org/jira/browse/XALANC-536): ElemNumber uses extra temporary strings * [XALANC-537](https://issues.apache.org/jira/browse/XALANC-537): XalanC source code quotes incorrectly license protected documents * [XALANC-526](https://issues.apache.org/jira/browse/XALANC-526): Use of undefined stricmp breaks compilation on Linux * [XALANC-513](https://issues.apache.org/jira/browse/XALANC-513): ICUFormatNumberFunctor has some MemoryManager issues * [XALANC-507](https://issues.apache.org/jira/browse/XALANC-507): Safety improvements for XalanVector::insert() * [XALANC-506](https://issues.apache.org/jira/browse/XALANC-506): Remove references to stlport directory in Makefile.incl.in * [XALANC-505](https://issues.apache.org/jira/browse/XALANC-505): DirectoryEnumerator.hpp will not build on Solaris 10 with Sun Workshop 10 * [XALANC-502](https://issues.apache.org/jira/browse/XALANC-502): XalanDOMStringCache has initializer list out of order * [XALANC-501](https://issues.apache.org/jira/browse/XALANC-501): Creation of comments and PIs needs to detect illegal values * [XALANC-500](https://issues.apache.org/jira/browse/XALANC-500): Remove old "diagnostic" output from StylesheetRoot and XSLTEngineImpl * [XALANC-497](https://issues.apache.org/jira/browse/XALANC-497): Local variables or parameters in EXSLT-functions are interpreted as global * [XALANC-496](https://issues.apache.org/jira/browse/XALANC-496): Glitches in header files * [XALANC-493](https://issues.apache.org/jira/browse/XALANC-493): Problem with XALAN_STATIC_CHECK on HP-UX IA64 * [XALANC-492](https://issues.apache.org/jira/browse/XALANC-492): Various pluggable memory management bugs. * [XALANC-490](https://issues.apache.org/jira/browse/XALANC-490): XalanFileReporter is inconsistent in its usage of pluggable memory management * [XALANC-489](https://issues.apache.org/jira/browse/XALANC-489): XalanMemMgrs has a thread-safety issue * [XALANC-488](https://issues.apache.org/jira/browse/XALANC-488): XSLTInputSource does not support pluggable memory management * [XALANC-487](https://issues.apache.org/jira/browse/XALANC-487): URISupport does not provide explicit MemoryManager * [XALANC-485](https://issues.apache.org/jira/browse/XALANC-485): GCC warns about order of members in initializer list * [XALANC-484](https://issues.apache.org/jira/browse/XALANC-484): Remove compiler warnings about placement delete for HP's aCC compiler * [XALANC-483](https://issues.apache.org/jira/browse/XALANC-483): XercesParserLiaison does not create Xerces-C DOM instances with namespaces support enabled. * [XALANC-482](https://issues.apache.org/jira/browse/XALANC-482): Remove compiler warnings * [XALANC-470](https://issues.apache.org/jira/browse/XALANC-470): runConfigure does not pass link options to Makefile for AIX platform * [XALANC-465](https://issues.apache.org/jira/browse/XALANC-465): Add alt tag to footer.html page under html/apiDocs tree. * [XALANC-463](https://issues.apache.org/jira/browse/XALANC-463): Transforming an XML DOM document encapsulated within an XercesDOMWrapperParsedSource object triggers an invalid heap pointer exception if XSL opens other XML document with 'document()' function. * [XALANC-460](https://issues.apache.org/jira/browse/XALANC-460): Linux/xlC port * [XALANC-448](https://issues.apache.org/jira/browse/XALANC-448): TestXSLT/process.cpp compilation fails, interface broken in FormatterToText.hpp * [XALANC-445](https://issues.apache.org/jira/browse/XALANC-445): generate-id() inserts periods into name which limits usage # 1.9 ## Major changes * Pluggable Memory Management. This feature allows applications to maintain precise control over memory allocations. This will allow users, with knowledge of their application's characteristics, to provide a more efficient allocation method than the general purpose procedures provided by the system. * Improved stability on the execution of large stylesheets and XML documents. Because the current implementation relies on function recursion, certain stylesheets/input documents may cause the program stack to overflow and cause the application to fail. It also may inhibit executing stylesheets that are heavily dependent on recursive functions. This feature will prevent these types of failure. * Provided a global option to pool all text node strings. This feature allows developers to set a flag to determine if a parsed source tree will pool the values of all of the text nodes in the XML document. By doing so, this can result in a significant reduction in memory usage, particularly if there are a lot of repeated values in text nodes. Please see the class descriptions for `XalanSourceTreeDocument`, `XalanDefaultParsedSource`, and `XalanTransformer` in the API reference.. * Added support for Microsoft Studio .NET V7.1. Project files for Microsoft Studio .NET V7.1 have been provided under the directory xalan\c\Projects\Win32\VC7.1. * Upgrade from Xerces-C 2.5 to Xerces-C 2.6. # 1.8 ## Major changes * Upgrade from Xerces-C 2.4 to Xerces-C 2.5. * Provide build support for Cygwin and HP-UX 11.00 on Itanium. Although binary distributions are not provided for the Cygwin environment and HP-UX 11.00 on Itanium platform, the build configuration files provided in the source distribution can be used to build on these platforms. * Project files for supporting Microsoft Visual Studio .NET. Although a binary distribution for the Microsoft Visual Studio .NET is not provided in this release, Visual Studio solution files are provided in the Windows source distribution for those who choose to build on this platform. * Additional changes to Xerces Deprecated DOM support. This is another step towards phasing out the support for Xerces Deprecated DOM. Users are encouraged to modify their applications to interface with the new Xerces DOM support. * Implemented optimizations to significantly improve the throughput of the ICU-enabled "format-number" function. * Changes in the XML Serializer. The serializer will no longer put a newline after the xml header tag unless indent="yes". See bugzilla [24304](http://nagoya.apache.org/bugzilla/show_bug.cgi?id=24304) and [28386](http://nagoya.apache.org/bugzilla/show_bug.cgi?id=28386). # 1.7 ## Major changes * Message Localization Support. This feature enables Xalan-C++ to issue diagnostic messages in languages other than the default language (English). In order to utilize this feature, the user must provide a version of the Xalan-C++ message catalog that has been translated in their language of choice. * Build, packaging, and installation improvements. Changes to the Xalan-C++ makefiles now allow for a more flexible build, packaging, and install process. Each step in a typical build process can be invoked by specifying the appropriate target, for example to build the executable, and/or samples, or install the build at user-specified location. * Deprecated DOM Support. The `XercesBridge` classes have been marked deprecated and moved into an exclusive directory within the `xalanc/XercesParserLiaison` directory called `Deprecated`. If your application is dependent on these classes to interface with the deprecated Xerces DOM you must alter your include directive with the `Deprecated` directory. For example: `#include ` should be changed to: `#include `. * Upgrade from Xerces-C 2.3 to Xerces-C 2.4. * Porting of `ThreadSafe` example to UNIX platform. * Implementation of EXSLT string extension functions `encode-uri()` and `decode-uri()`. * Implementation of EXSLT dynamic extension function `evaluate()`. * Implementation of EXSLT date-time extension function `date-time()`. # 1.6 ## Major changes Directory "sane include" reorganization. A new sub-directory called `xalanc` has been added to the `src` directory (for source distribution packages) and `include` directory (for binary distribution packages). New source files which include Xalan headers will need to be modified to include the `xalanc` prefix in the header path. For example: ``` #include ``` will need to be changed to ``` #include ``` For Windows users, all project files have been modified to reflect this change. # 1.5 ## Major changes * For Windows, Xalan-C++ is now packaged as a single DLL. The project files to build separate DLLs are now deprecated and will not be maintained. * Support for Xerces-C++ `DOMNode` classes. * New sample `TransformToXercesDOM` that illustrates how to perform a transform resulting in a Xerces-C++ DOMDocument * Usage of the Xerces-C++ C++ namespace and creation of Xalan-C++ namespace. # 1.4 ## Major changes * The Xalan-C++ distributions no longer include the Xerces-C++ headers and libraries. Accordingly, you must download the appropriate Xerces-C++ distribution. * 64-bit build for HP-11; untested 64-bit support for Solaris and AIX. * New Linux platform and compiler: Redhat 7.2 with gcc 3.1. * STLPort is no longer required on any of our supported platforms. * Alpha support for a number of EXSLT functions. * `ParsedSourceWrappers`, a sample that illustrates how to perform transformations with input in the form of a pre-built `XalanDOM` or `XalanSourceTree`. # 1.3 ## Major changes * A new and simplified command-line utility: the Xalan executable * New XPath samples exploiting the XPathEvaluator C API and illustrating serialization of an XPath result set: `SimpleXPathCAPI` and `SerializeNodeSet` * A new wrapper class that lets you pass in a Xerces DOM as input for a transformation * Bug fixes. * Changed `XPathException` to `XalanXPathException` because of a clash with a new Xerces class of the same name. # 1.2 ## Major changes * Introduction of a library of extension functions * Support for pre-parsed source documents and pre-compiled stylesheets in `XalanTransformer` and the C API. * Support for stylesheet params in `XalanTransformer` and the C API * Support for extension functions in `XalanTransformer` * Performance enhancements # 1.1 ## Major changes In addition to adding to the list of platforms on which Xalan-C++ builds, our focus for this release has been on bug fixes, performance enhancements, and providing a simplified C++ and C API for performing standard transformations. Major updates include: * Added HP-UX 11 build. * Added Solaris build. * Greatly improved performance. * Improved conformance to the XSLT specification. * Simplified the C++ API and provided a C API for performing standard transformations with the `XalanTransformer` class and associated header files. * Added sample illustrating use of XalanTransformer and the new C++ API: `XalanTransform`. * Added sample illustrating use of XalanTransformer, the new C API, and how to run Xalan-C++ and perform transformations on an Apache Web server: `ApacheModuleXSLT`. * Added the `StreamTransform` sample. * Eliminated dependencies on non-public Xerces headers; accordingly can now build with the Xerces distribution. * Fixed namespace mapping and inheritance problems. * Fixed failure of `` to include CRLFs (if any) in the result. * Fixed bug sorting in reverse document order based on position. * Fixed `` bug with use of letter-value="traditional" for "classical" Greek numbering. * Fixed use of `` within a top-level extension function. * Fixed HTML output method bug. The `` element was not including a `` tag with the encoding. * Fixed bug using `key()` in match patterns to find descendants. * Fixed bug using the `id()` function in complex match patterns. * Fixed problem outputting multiple single-character CDATA sections. * Fixed problem outputting whitespace characters. * Fixed problem transforming from a stream on UNIX platforms. * Fixed a bug with the `document()` function, which was generating a syntax error if called in the following manner: `document(string,/)`. * Fixed named templates bug accepting global parameter when called with a parameter of the same name that the named template does not recognize. # 1.0 ## Major changes * Full support for namespace handling * Full implementation of the `format-number()` function and support for the decimal-format element * Integration with the ICU for number formatting, sorting, and output encoding * Support for the `exclude-result-prefixes` attribute * Support for the output `encoding` attribute # 0.40.0 ## Major changes * Permitting OS file names (as well as URLs) as command-line arguments with TestXSLT * Stricter compliance for HTML and XML output * Improved handling of relative URI's * Improved handling of Import and Include * Better namespace handling (although there are still problems here) * Support for `Document()` function * Support for XPath predicates * ProblemListener with a different output stream and call `XalanTransformer::setProblemListener()` before calling `XalanTransformer::transform()`. xalan_c-1.12/docs/licensing.md000644 001751 001751 00000027775 13667130245 017110 0ustar00rleighrleigh000000 000000 # Apache Software License Version 2.0 ## Xalan Software License Notice ``` ======================================================================= == NOTICE file corresponding to section 4(d) of the Apache License. == == Version 2.0, in this case for the Apache Xalan distribution. == ======================================================================= Apache XALAN-C Copyright (c) 1999-2012 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). This software is based on the ASF XERCES-C project. Portions of this software were originally based on the following: - software copyright (c) 1999, IBM Corporation. (http://www.ibm.com). Additional copyright submissions and contributions: -------------------------------------------------------------------------- ``` ## Apache Software License Text ``` Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ``` xalan_c-1.12/docs/programming.md000644 001751 001751 00000005447 13667130245 017447 0ustar00rleighrleigh000000 000000 # Programming tips ## Introduction This section was created to guide users on how to use some of the new features going into the Xalan source code base. Some of the features discussed in this section are based on feedback and questions posted on the xalan-c-users newsgroup. This section will cover the benefits of certain features and provide users with programming hints on how to utilize the features in their applications. ## Pluggable Memory Management Pluggable memory management was added as a new feature in Xalan-C++ Version 1.8. This feature introduces an object called `MemoryManager` which allows applications with stricter memory management requirements to utilize a more efficient allocation method. This `MemoryManager` object can be applied to each processor instance, thus recovery procedures from memory leaks or processor crashes will be applied to the associated instance only. The memory management model is similar to the memory management feature provided by the Xerces-C++ XML Parser. ### How To Use This Feature To apply memory management to your application, the `MemoryManager` object needs to be specified in two stages: * At initialization phase. The purpose of specifying a `MemoryManager` object during initialization is to create a separate memory manager for the overall application. Example of how this can be done is shown in the example below: ```c++ // Initialization step static void XalanTransformer::initialize(MemoryManager* initMemoryManager=0); ``` * Creation of a transformer instance. This creates a unique memory manager for the instance of the processor. This step is optional. If no memory manager is provided, the global heap is used as the memory source. Example of this is shown below: ```c++ // Create instance of XalanTransformer MemoryManager memMgrA; // memory manager object XalanTransformer transformerA(&memMgrA); MemoryManager memMgrB; XalanTransformer transformerB(&memMgrB); XalanTransformer transformerC(&memMgrB); // Uses same memory manager object as transformerB XalanTransformer transformerD; // Uses default static memory manager ``` The above method demonstrates how users can apply the basic pluggable memory management feature. Users also have the option of implementing their own memory manager. This can be done by simply writing methods for: ```c++ // Method for allocating memory void* allocate(size_t size); ``` and ```c++ // Method for deallocating memory void deallocate(void *p); ``` For an example of how to use this feature, please see the [SimpleTransform](samples.md#simpletransform) sample that has been provided in the binary distributions. ## More Topics Please feel free to give us feedback on what topics you would like to see. Send comments to the Xalan Development Mailing List. xalan_c-1.12/docs/introduction.md000644 001751 001751 00000021403 13667130245 017634 0ustar00rleighrleigh000000 000000 # Introduction ## Xalan-C++ Xalan-C++ version is a robust implementation of the W3C Recommendations for [XSL Transformations (XSLT)](http://www.w3.org/TR/xslt) and the [XML Path Language (XPath)](http://www.w3.org/TR/xpath). It works with the [Xerces-C++](http://xerces.apache.org/xerces-c) XML parser. The Xalan-C++ project creates and distributes a standard XSLT library and a simple [`Xalan`](commandline.md) command-line utility for transforming XML documents. This project is written in a reduced set of the C++ programming language. This makes the library directly usable on numerous platforms. A set of 'C' language APIs is also available so that XSLT and XPath functionality is easily deployed to 'C' language applications. [Sample programs](samples.md) are available for you to test and experiment with as you learn the Xalan library. Some of the [EXSLT extension functions](http://www.exslt.org) for XPath are available. We need to write and validate more of the EXSLT functions. A library of [XPath extensions](extensionslib.md) is provided by the Apache Xalan community. Documentation and examples are available for you to write your own custom [XPath extensions](extensions.md). ## Licenses The Xalan-C++ software conforms to The [Apache Software Foundation License, Version 2.0](licensing.md). ## Getting Involved You are invited to participate in [The Apache Software Foundation](http://www.apache.org/foundation/getinvolved.html). You will need to subscribe if you wish to receive mail from the lists. Some lists require a subscription in order to post messages. The *xalan-dev* (`dev@xalan.apache.org`) mailing list is used to communicate product development issues with the software development team. The xalan-dev messages are [archived here](http://mail-archives.apache.org/mod_mbox/xalan-dev) and on [Marc.info](http://marc.info/?l=xalan-dev). The *xalan-c-users* (`c-users@xalan.apache.org`) mailing list is used to discuss issues regarding the use of the Xalan-C++ software and libraries. The xalan-c-users messages are [archived here](http://mail-archives.apache.org/mod_mbox/xalan-c-users) and on [Marc.info](http://marc.info/?l=xalan-c-users). The Git repository changes are logged on the *xalan-commits* mailing list and are [archived here](http://mail-archives.apache.org/mod_mbox/xalan-commits) and on [Marc.info](http://marc.info/?l=xalan-cvs). You can review the project sources and change history in the Git repository on [GitHub](https://github.com/apache/xalan-c) or [Apache GitBox](https://gitbox.apache.org/repos/asf?p=xalan-c.git). You can clone a private copy of the repository using either service. The [JIRA](https://issues.apache.org/jira/projects/XALANC) system is used for issue tracking. You must create an account before you can post messages and files to the JIRA tracking system. You can view the issues at [https://issues.apache.org/jira/projects/XALANC](https://issues.apache.org/jira/projects/XALANC). ## XSLT Standards Implemented Xalan-C++ implements the following specifications from the World Wide Web Consortium (W3C). * [XSL Transformations (XSLT) Version 1.0](http://www.w3.org/TR/xslt) * [XML Path Language (XPath) Version 1.0](http://www.w3.org/TR/xpath) * [Associating Style Sheets with XML documents 1.0 (Second Edition)](http://www.w3.org/TR/xml-stylesheet) The next major release of Xalan-C++ will hopefully be compatible with the following standards: * [XSL Transformations (XSLT) Version 2.0](http://www.w3.org/TR/xslt20) * [XSLT 2.0 and XQuery 1.0 Serialization](http://www.w3.org/TR/xslt-xquery-serialization) * [XML Path Language (XPath) Version 2.0 (Second Edition)](http://www.w3.org/TR/xpath20) * [XQuery 1.0 and XPath 2.0 Formal Semantics (Second Edition)](http://www.w3.org/TR/xquery-semantics) * [XQuery 1.0 and XPath 2.0 Data Model (XDM) (Second Edition)](http://www.w3.org/TR/xpath-datamodel) * [XQuery 1.0 and XPath 2.0 Functions and Operators (Second Edition)](http://www.w3.org/TR/xpath-functions) This added support will require a major version change from 1 to 2. ## XML Parser Library Xalan-C++ uses the The Apache Software Foundation Xerces-C project that implements parsers for XML 1.0 and XML 1.1. The following standards as specified by the [World Wide Web Consortium (W3C)](http://www.w3.org/TR) are implemented by the [Xerces-C++](http://xerces.apache.org/xerces-c) XML parser library: * [Extensible Markup Language (XML) 1.0 (Third Edition) - currently (Fifth Edition)](http://www.w3.org/TR/xml) * [Extensible Markup Language (XML) 1.1 (First Edition) - currently (Second Edition)](http://www.w3.org/TR/xml11) * [xml:id Version 1.0](http://www.w3.org/TR/xml-id) * [XML Base (Second Edition)](http://www.w3.org/TR/xmlbase) * [XML Information Set (Second Edition)](http://www.w3.org/TR/xml-infoset) * [Namespaces in XML 1.0 (Third Edition)](http://www.w3.org/TR/xml-names) * [Namespaces in XML 1.1 (Second Edition)](http://www.w3.org/TR/xml-names11) * [XML Schema Part 1: Structures Second Edition](http://www.w3.org/TR/xmlschema-1) * [XML Schema Part 2: Datatypes Second Edition](http://www.w3.org/TR/xmlschema-2) * [Document Object Model (DOM) Level 1](http://www.w3.org/TR/REC-DOM-Level-1) * [Element Traversal Specification](http://www.w3.org/TR/ElementTraversal) * [Document Object Model (DOM) Level 2 Core Specification](http://www.w3.org/TR/DOM-Level-2-Core) * [Document Object Model (DOM) Level 2 Traversal and Range Specification](http://www.w3.org/TR/DOM-Level-2-Traversal-Range) * [Document Object Model (DOM) Level 3 Core Specification](http://www.w3.org/TR/DOM-Level-3-Core) * [Document Object Model (DOM) Level 3 Validation Specification](http://www.w3.org/TR/DOM-Level-3-Val) * [Document Object Model (DOM) Level 3 Load and Save Specification](http://www.w3.org/TR/DOM-Level-3-LS) * [XML Inclusions (XInclude) 1.0 (Second Edition)](http://www.w3.org/TR/xinclude) Xerces-C++ also supports the [SAX 1.0 and SAX 2.0](http://sax.sourceforge.net/) projects. SAX is primarily Java based. The Xerces-C++ project has implemented a SAX C++ API that looks much like the SAX Java API. Web Services and Web Security recommendations have been developed by the [World Wide Web Consortium (W3C)](http://www.w3.org) and [OASIS-OPEN](http://www.oasis-open.org) Advancing open standards for the information society. Xerces-C++ has support for custom entity resolvers which are inherited and supported by the Xalan-C++ library. ## Security Issues The Xalan-C++ library has hooks so that custom entity resolvers can be deployed. The entity resolvers are actually interfaces into the Xerces-C++ XML Parser Library. Use of trusted entity resolvers greatly increases the security of XML based applications. The Web Services Architecture uses specifications and recommendations that are documented by the following organizations: * World Wide Web Consortium (W3C) [[http://www.w3.org](http://www.w3.org)] * Advancing open standards for the information society (OASIS-OPEN) [[http://www.oasis-open.org](http://www.oasis-open.org)] * The Sourceforge SAX Project (SAX1, SAX2) [[http://sax.sourceforge.net](http://sax.sourceforge.net)] * Internet Engineering Task Force (IETF) [[http://www.ietf.org](http://www.ietf.org)] There are some [architecture security](secureweb.md) issues that should be addressed by any XML parser or XSLT transformation application. Other than validating and cleaning the content of XML elements, the access to untrusted external entities is a big problem for security management. The [`Xalan`](commandline.md) command-line transformation program does not deploy an OASIS catalog or perform other security measures. URLs are resolved using the system directory of the local machine and DNS to resolve host locations. The `Xalan` program should be used only with trusted XSLT stylesheets and XML documents on a trusted computer. A future release of the `Xalan` command-line transformation program may include support for an OASIS entity resolver catalog. Information on creating Secure Web Service Applications is useful for review. This [security overview document](secureweb.md) goes beyond the scope of XSLT transformations and asks many pertinent security based questions. ## Getting Started See the [download](download.md) and [build](build.md) instructions for how to build Xalan-C++ from source. See the [install](install.md) for how to install prebuilt packages for your operating system directly. The current Xalan-C++, Version 1.12, is compatible with the stable releases of [Xerces-C++](http://xerces.apache.org/xerces-c), Version 3.0 and newer. The current stable release for Xerces-C++ is 3.2.3. If you are having problems using the product, send your comments to the *xalan-c-users* (`c-users@xalan.apache.org`) mailing list. If you think a change needs to be made or have suggestions for future releases, send your comments to the *xalan-dev* (`dev@xalan.apache.org`) mailing list. xalan_c-1.12/docs/download.md000644 001751 001751 00000004336 13667130245 016730 0ustar00rleighrleigh000000 000000 # Downloading Xalan-C++ Xalan-C++ may be obtained in two ways: 1. Binary distribution. 2. Source distribution. ## Binary distribution See the [Installing Xalan-C++](install.md) chapter for further details. ## Source distribution The Xalan-C++ sources may be downloaded from: * [An Apache mirror](http://www.apache.org/dyn/closer.cgi/xalan/xalan-c/sources) of the official release files. * GitHub [releases](https://github.com/apache/xalan-c/releases) of the same files. * GitHub [tags and branches](https://github.com/apache/xalan-c) downloads. * Apache GitBox [source browser](https://gitbox.apache.org/repos/asf?p=xalan-c.git) or direct Git URI: `https://gitbox.apache.org/repos/asf/xerces-c.git` Note: You must [verify the integrity](#verify-the-integrity-of-the-files) of the downloaded files using signatures downloaded from the Apache master distribution directory. Note: To access previous releases of Xalan-C++, visit the [Apache Xalan-C++ archives](http://archive.apache.org/dist/xml/xalan-c/). To access previous releases of Xerces-C++, visit the [Apache Xerces-C++ archives](http://archive.apache.org/dist/xerces/c/) After downloading the sources, proceed to [Building Xalan-C++](build.md) to build Xalan-C++ ## Verify The Integrity of the Files It is essential that you verify the integrity of the downloaded files using the PGP or MD5 signatures. You should only download the [KEYS](http://www.apache.org/dist/xalan/xalan-c/KEYS) and the (asc/md5) signature files from the Apache Master Distribution. The Apache Mirrors of previous sections should be used to download the products. * [Apache Mirror Xalan-C Sources](http://www.apache.org/dyn/mirrors/mirrors.cgi/xalan/xalan-c/sources) * [Apache Master Xalan-C Sources - for Signature Files](http://www.apache.org/dist/xalan/xalan-c/sources) Make sure you get the signature file for the particular distribution from the master directory, rather than from a mirror. Then verify the signatures using: ```sh % pgpk -a KEYS % pgpv .tar.gz.asc ``` *or* ```sh % pgp -ka KEYS % pgp .tar.gz.asc ``` *or* ```sh % gpg --import KEYS % gpg --verify .tar.gz.asc ``` Alternatively, you can verify the MD5 signature on the files. xalan_c-1.12/docs/secureweb.md000644 001751 001751 00000031446 13667130245 017107 0ustar00rleighrleigh000000 000000 # XML Security Overview This document goes well beyond XSLT. Use it as a general reference. There are numerous security issues and problems that are endemic to the XML architecture. I will try to identify some of the most common issues and threats and describe some mitigation strategies. The biggest threat issue is a matter of trust. How well do you trust your sources of XML data? What are the tools that can help increase the trust? Most Web Service communications uses HTTP over standard TCP ports. The HTTP protocol on standard TCP ports has free access through business firewalls. How well do your proxy servers handle the Web Service security issues required for your applications? How well are your resource identifiers protected? How well do your applications cope with resource identifier spoofing? Can your resource identifiers be trusted by outside clients? Can you trust the credentials of your clients? Will the SOAP interface for your Web Service send error messages to an untrusted Web Service address? Is your WSDL interface description file readily available for download, thus enabling persons with malicious intent to create targeted attacks on your Web Services? Can you trust the client credentials that use your Web Service application? There are numerous security issues that are not directly involved in the markup of XML or its processing. These issues relate to infrastructure. Can you trust your DNS (Domain Name Service) and reduce its vulnerability to hijacking? Are your web servers hardened against known application vulnerabilities? Are your applications hardened against cross site scripting and SQL injection? Can your client applications trust the scripts that are transmitted as web pages? Can your web server trust the scripts that are submitted? Is application data sanitized before being consumed by your applications? ## XML Parser Threats This list will help you find the XML threat vectors that need to be addressed. Some vectors cannot be easily resolved. * Resolving External Entities * Implicit Trust of Internal DTD * Resource Identifier Spoofing * Malformed UTF-8 and UTF-16 * Secure the trust of external DTD descriptions * Secure the trust of external Schema definitions * Secure the trust of entity import and include constructs * Configuration of Entity Resolver Catalogs Resolving External Entities The XML1.0 and XML1.1 standards specify a `DOCTYPE` format. The processing may uncover significant entity resolver deficiencies. ```xml ``` ```xml ``` XML Parsers MUST process the `[internal-DTD]` if it exists. XML Parsers MAY process the external `"system-id"` if it can be found. XML Parsers MAY process the external `"public-id"` if it can be found. XML Parsers MAY prefer either the `"public-id"` or `"system-id"` if both are specified. XML Parsers MAY ignore both the `"public-id"` and `"system-id"` if present. Declaring a parameter entity notation `"%entity;"` in the `[internal-DTD]` and expanding the content within the `[internal-DTD]` will force the XML parser to import the content referenced by the `"%entity;"` notation. Declaring a general entity notation `"&entity;"` in the `[internal-DTD]` and expanding the content within the body of the XML document will force the XML parser to import the content referenced by the `"&entity"` notation. The default method of resolving external entities is by resolving entity name strings relative to DNS named hosts and/or path names relative to the local computer system. When receiving XML documents from an outside source, these entity reference locations may be unreachable, unreliable, or untrusted. Web Service SOAP XML documents MUST NOT have `DOCTYPE` definitions. SOAP processors should not process `DOCTYPE` definitions. The conformance is implementation dependent. [http://www.w3.org/TR/soap](http://www.w3.org/TR/soap) ## Trusted External Entities The *OASIS XML Catalogs* specification, if implemented by an application, can specify a set of external entities that can be trusted by mapping known identifiers to local or trusted resources. A secure application should not trust entity identifiers whose resources cannot be localized and secured. [http://www.oasis-open.org/committees/entity](http://www.oasis-open.org/committees/entity) A similar method can be designed specifically for each application. A trusted application may need to pre-screen any entity definitions in XML before passing the information into the core of the application. A trusted application should install some type of entity resolving catalog or database that can be trusted. ## Processing Instruction (PI) Threats Processing instructions are a mechanism to send specific information into an application. A common processing instruction is a stylesheet declaration. This information is part of an XML document and comes usually after the XML header and before the root element. A stylesheet declaration may cause an application to look for an untrusted XSLT stylesheet to use for transformation of the following root element. A standard exists for associating style sheets with XML documents. [http://www.w3.org/TR/xml-stylesheet](http://www.w3.org/TR/xml-stylesheet) Examples in the *xml-stylesheet* recommendation describe how to use the processing instruction to associate CSS stylesheets for XHTML. Applications that use XSLT transformations will interpret the xml-stylesheet processing instruction as the location of a XSLT transformation stylesheet. As more processing instructions become standardized and in common use, their threat of misuse increases. ## SOAP Simple Object Access Protocol The SOAP specification explicitly forbids the transport of `DOCTYPE` definitions and PI processing instructions. The SOAP specifies a transport envelope that encapsulates an XML message for transport. SOAP can also handle various transmission status indicators implying confirmation of delivery, error messages, and queue status messages. SOAP transports can be loosely coupled and intermittent. SOAP is used extensively in the design and deployment of Web Service architectures. A companion Web Service specification is WSDL, the Web Service Definition Language. The SOAP protocol as widely deployed by Microsoft and other vendors is based on specifications that predate the adoption by the [World Wide Web Consortium (W3C)](http://www.w3.org). SOAP is not based on Microsoft technology. It is an open standard drafted by UserLand, Ariba, Commerce One, Compaq, Developmentor, HP, IBM, IONA, Lotus, Microsoft, and SAP. [SOAP 1.1](http://www.w3.org/TR/2000/NOTE-SOAP-20000508) was presented to the W3C in May 2000 as an official Internet standard. The original [SOAP 1.1](http://www.w3.org/TR/soap11) standard is associated with this URI namespace prefix: `http://schemas.xmlsoap.org/soap/` There are significant changes in naming conventions since SOAP 1.1 was adopted by W3C as a recommended standard. The current iteration is [SOAP 1.2](http://www.w3.org/TR/soap12) and is associated with this URI namespace prefix: `http://www.w3.org/2003/05` The basic security threat to the SOAP architecture is the ability to spoof Web Service addresses and telling a SOAP server to respond to a rogue Web Service address when a `mustUnderstand` attribute is processed and an error indication is raised. Other intelligence that can be obtained might be the location of a public accessible WSDL definition of the messages being transported by SOAP, thus allowing additional malware attacks to be automatically generated. ## WSDL Web Service Description Language WSDL is known as the Web Service Description Language. The WSDL XML document is a an interface description that can be transformed into various programming languages. Such transformed interface descriptions are recognized as Java Interfaces and C++ Virtual Classes. The original [WSDL 1.1](http://www.w3.org/TR/wsdl) standard is associated with this URI namespace prefix: `http://schemas.xmlsoap.org/wsdl/` The current [WSDL 2.0](http://www.w3.org/TR/wsdl20) standard is maintained by W3C in their namespace with prefix: `http://www.w3.org/` The WSDL can provide a template for generating a compliant Web Service systems for multiple and hetrogeneous platforms. A WSDL document that can benefit developers can also be used by malware and hackers to tailor specific threats against targeted Web Services. The SOA (Service Oriented Architecure), SAAS (Software As A Service), PAAS (Platform As A Service) are families of Web Services used as interfaces into what is generally known as Cloud Computing. ## URI Uniform Resource Identifiers The URI does not need to specify the location of a resource. It merely provides a resource name. A catalog, database, or other mechanism is used to map URIs to resource locations. The security issue here is that most URIs are used with a DNS (Domain Name Service) to find a host and path to a resource. The URI is then treated as a URL (Uniform Resource Locator). The mitigation of these threats requires diligence of the application architects to ensure an appropriate level of trust for the URIs and URLs used in their applications. The transmission media is inherently untrusted. Often SOAP bindings and HTTP transports are used. Web Service addressing is readily spoofed. ## URL Uniform Resource Locators See [URI Uniform Resource Identifiers](#uri-uniform-resource-identifiers) ## Malformed UTF-8 and UTF-16 Strings Public Key Infrastructure (X.509) certificates are leased from a certificate authority or are self-signed. The distinguished names and parts thereof are usually rendered in unicode. The value of zero is not a valid Unicode character. It is possible to create non-zero UTF-8 and UTF-16 sequences that equate to zero, which is not allowed. Some rogue hackers have successfully obtained wild-card PKI (X.509) certificates by prepending a UTF-8(zero) in a distinguished name when applying for a certificate. Such a certificate could be used to successfully sign anything. Applications should not blindly accept UTF-8 and UTF-16 strings without verifying the proper encoding for those strings. Contents that equate to bad Unicode character values should be denied. ## Canonical XML Issues Canonical XML is a tranformation of an XML document into a canonical form useful for signing. This is used in some Web Service security implementations. There are several areas where Canonical XML will create XML documents that have severe application problems. The number values are rendered in Base-10 as decimal fractions. The computations performed by computers are usually in Base-2 floating point arithmetic. You therefore have truncation or roundoff issues when converting between decimal fractions and Base-2 fractions. The canonical process may collapse whitespace and transform multi-character line endings to single-character line endings. When whitespace is significant, the canonical issues for signing can cause problems. It is possible to create XHTML documents that will not work with some browsers. The empty `` anchor element is not allowed by many browsers, therefore `` is required. A standard XML canonical process may collapse elements with no content into empty elements. The empty paragraph `

` is disallowed. The `

` is supported. The World Wide Web Consortium (W3C) has additional detailed discussion of [canonicalization issues](http://www.w3.org/TR/C14N-issues/) ## XHTML Output Mode - Workaround The Xalan-C/C++ library currently has no XHTML output mode. Since XHTML is to be well-formed XML, the desire is to use the XML output method. XHTML is based on HTML version 4. Empty elements declared by HTML-4 should have a space before the trailing `/>` markup (i.e. `
` and `
`). XML output mode does not normally have this space when using the `` in your stylesheet. Most modern browsers are ok with no space, but viewing the browser source shows a warning condition. Non-empty elements declared by HTML-4 should not be rendered as empty XML elements. If there is no content, the elements should be rendered with both a start-tag and end-tag (i.e. ``) instead of an XML empty-element. XSLT processors usually create an empty-element (i.e. ``) when the element being defined has no content other than attributes. For XSLT processors creating XML documents for XHTML, you can create what looks like an element with no content by including the `‌` character (a zero-width non-joining character often known as `‌`) as the element text content. This also allows transitional browsers the ability to find the end tag. ``` DTD ‌ ```` Transitional XHTML is not usually well-formed XML. It becomes a mix of HTML version 4 and XML markup. Strict XHTML is required to be well-formed XML. xalan_c-1.12/docs/commandline.md000644 001751 001751 00000004225 13667130245 017404 0ustar00rleighrleigh000000 000000 # Xalan-C++ Command-Line Utilities ## Initial setup To perform a transformation, you can call Xalan-C++ from the command line (or script), or from within an application (see [Usage Patterns](usagepatterns.md)). To perform a transformation from the command line or a script, do the following: 1. [Download](download.md) and [build](build.md) Xalan-C++, or [install](install.md) Xalan-C++ from a third-party distributor. 2. Set the path and/or library path to include the Xalan executable and the Xalan-C++ and Xerces-C++ libraries, respectively. 3. Call the Xalan executable with the appropriate flags and arguments (described below). ## Using the `Xalan` executable Call the `Xalan` executable as follows: ```sh Xalan [options] xmlSource xslStylesheet ``` where *xmlSource* is the XML source document, *xslStylesheet* is the stylesheet to apply, and *options* are any (or none) of the following: | Option | Description | |----------------|------------------------------------------------------------------------| | *-a* | Use stylesheet processing instruction, not the stylesheet argument. | | *-e encoding* | Force the specified encoding for the output. | | *-i integer* | Indent the specified amount. | | *-m* | Omit the META tag in HTML output. | | *-o filename* | Write transformation result to this file (rather than to the console). | | *-p name expr* | Set a stylesheet parameter with this expression. | | *-t name expr* | Display timing information. | | *-u name expr* | Disable escaping of URLs in HTML output. | | *-v* | Validate the XML source document. | | *-* | A dash as the *xmlSource* argument reads from stdin.
A dash as the *xmlStylesheet* argument reads from stdin.
("-" cannot be used for both arguments.) | To display a list of the options call the Xalan executable as follows: ```sh Xalan -? ``` xalan_c-1.12/docs/charter.md000644 001751 001751 00000037651 13667130245 016557 0ustar00rleighrleigh000000 000000 # Xalan Project Charter The following charter applies to all Xalan projects. ## 1 INTRODUCTION 1.1 Apache Xalan is a collaborative software development project dedicated to providing robust, full-featured, commercial-quality, and freely available XSLT support on a wide variety of platforms. This project is managed in cooperation with various individuals worldwide (both independent and company-affiliated experts), who use the Internet to communicate, plan, and develop XSLT software and related documentation. 1.2 This charter briefly describes the mission, history, organization and processes of the project. ## 2 MISSION 2.1 Apache Xalan exists to promote the use of XSLT. We view XSLT (Extensible Stylesheet Language Transformations) as a compelling paradigm that transforms XML documents, thereby facilitating the exchange, transformation, and presentation of knowledge. The ability to transform XML documents into usable information has great potential to improve the functionality and use of information systems. We intend to build freely available XSLT processing components in order to engender such improvements. 2.2 Apache Xalan consists of a set of components that transform XML documents. Where appropriate, these components plug into other XML components using standard APIs (formal, de facto, or proposed). The components must be high performance, reliable, and easy to use. Where inter-related, the components must be part of an underlying architectural orchestration that will allow them to work together without major negotiations or breakage. 2.3 We believe that the best way to define this XML transformation architecture is by having both individuals and corporations collaborate on the best possible infrastructure, APIs, code, testing, and release cycles. Components must be vendor neutral and usable as core components for all. 2.4 In order to achieve a coherent architecture between Apache Xalan components and other components and applications, standards (formal or de facto) will be used as much as possible for both protocols and APIs. Where appropriate, experiences and lessons learned will be fed back to standards bodies in an effort to assist in the development of those standards. We will also encourage the innovation of new protocols, APIs, and components in order to seed new concepts not yet defined by standards. ## 3 HISTORY 3.1 This project was established under the direction of the Apache Software Foundation in October 2004 to facilitate joint open-source development. Prior to October 2004 this project was a subproject of the Apache XML project. ## 4 TERMS 4.1 The ASF Board. The management board of the Apache Software Foundation. 4.2 The Project. The Apache Xalan project; intended to refer to the source code, website, subprojects, and community that are Apache Xalan. 4.3 Subproject. The Apache Xalan project may have subprojects; a subproject is responsible for a component or application whose scope is well defined. 4.4 Product. Some deliverable (usually a binary or source package) that a subproject makes available to the public. Subprojects may have multiple products. 4.5 Release. A specific version of a product. Subprojects may have multiple releases of a given product. 4.6 Contributor. Anyone who makes a contribution to the development of the Apache Xalan project. 4.7 Committer. The Apache Xalan project has a set of committers. Committers are contributors who have read/write access to the source code repository. 4.8 PMC. The PMC (Project Management Committee) is the group of people that form the entity that makes decisions and controls the project. Individual people or committers do not control the project. ## 5 THE PROJECT MANAGEMENT COMMITTEE 5.1 The Apache Xalan project is managed by a core group of committers known as the Project Management Committee [PMC]. Subprojects, if any, much each have at least one representative committer on the PMC. 5.2 The activities of the PMC are coordinated by the Chairperson, who is an officer of the corporation and reports to the Apache Board. The Chairperson will, on the request of the Apache Board, provide reports to the Board on issues related to the running of the Apache Xalan project. 5.3 The PMC has the following responsibilities: a) Accepting new subproject proposals, formally submitting these proposals for Apache Xalan committer vote, and creating the subproject (see SUBPROJECTS below). This is done in collaboration with the Incubator (see [http://incubator.apache.org](http://incubator.apache.org)). b) Facilitating code or other donations by individuals or companies, in collaboration with the Incubator. c) Resolving license issues and other legal issues in conjunction with the ASF board. d) Ensuring that administrative and infrastructure work is completed. e) Facilitating relationships among projects and subprojects. f) Facilitating relationships between the Apache Xalan project and the external world. g) Overseeing Apache Xalan to ensure that the mission defined in this document is being fulfilled. h) Resolving conflicts within the project. i) Reporting to the ASF board (through the Chair) on the progress of the project. j) Propose new releases of projects or subprojects. Such proposals pass if 75% of the PMC members vote in agreement. 5.4 A contributor can, at any time, nominate a committer to be on the PMC, by calling for a vote. If two thirds, or more, of the active committers vote in agreement then the nomination is given to the PMC. The person becomes a new PMC member if 75% or more of the PMC members vote in agreement, with no dissenting votes among the PMC members. This individual should be elected based on merit for the evolution of the project and demonstration of commitment. 5.5 In cases where the subproject is unable to directly provide a representative on the PMC, another member of the PMC will be required to represent that subproject on the PMC. This will be strongly discouraged. It is preferable that all subprojects have direct representation on the PMC. 5.6 At least every twelve months, or more often if directed by the ASF board, the PMC members will elect a Chairperson from among themselves; the person with the most votes from the other PMC members is recommended to the ASF board for the position of Chairperson, and with the ASF board's approval, becomes the Chairperson for the new term. 5.7 Upon agreement by the Apache Board, the recommended Chairperson will, if they are not already, be appointed an officer of the corporation. See [http://www.apache.org/foundation/bylaws.html](http://www.apache.org/foundation/bylaws.html) for more information. 5.8 The PMC is responsible for maintaining and updating this charter. Development must follow the process outlined below, so any change to the development process necessitates a change to the charter. Proposed changes to this charter by the PMC are passed if 75% or more of the PMC members approve the proposal, with no dissenting votes. However, an active Apache Xalan committer may challenge the change. 5.9 An active Apache Xalan committer may challenge a change to this charter proposed by the PMC within two weeks of its proposal. When challenged the proposed change is passed if within two weeks of the challenge the active committers approve the change with a two-thirds majority vote. 5.10 The PMC ultimately makes the decisions for the project, not the individual people. At any time the PMC can reject patches or other contributions to the project if 75% or more of the PMC members vote to reject the contribution. 5.11 A PMC member may resign their membership at any time. However, in the unlikely event that a member of the PMC becomes disruptive to the process, such as ceasing to take part in PMC votes, the PMC member may be removed from the PMC by a vote among the other PMC members. The PMC member is removed if 75% or more of the other PMC members approve the removal, with no dissenting votes among the other PMC members. 5.12 A person remains a PMC member until he or she resigns, is removed by a vote from among the other PMC members, dies or is incapacitated. ## 6 SUBPROJECTS 6.1 A subproject of the Apache Xalan project is responsible for a component or application whose scope is well defined. Each subproject has its own set of developers, and is responsible for approving its own committers. Apache Xalan is composed of subprojects which fit into one of two categories: (a) An XSLT processor implementation in some particular programming language. There may be multiple processors for a given language if the API's the processors support are sufficiently dissimilar. At the time of writing, there is one processor for C++ and two for Java. (b) A set of components which are used in related applications and are tightly bound, usually through internal API's, to one (or more) of the processor subprojects. 6.2 A new subproject proposal is submitted to the PMC, and then accepted by a majority Apache Xalan project active committer vote within two weeks after the proposal. 6.3 Each subproject must have a set of requirements as well as an up-to-date release plan and design document on its dedicated web page. 6.4 It is recommended that each subproject have a smoke-test system that works at least as a basic integration test. 6.5 A subproject may be removed if 75% or more of the PMC members approve the proposal, there are no dissenting votes among the PMC members, and no challenges by active Apache Xalan project committers within two weeks after the proposal. A contributor may challenge the proposed removal of a subproject within two weeks of the proposal. In this case the proposed removal is passed if within two weeks of the challenge the active committers approve the removal with a two-thirds majority vote. Any subproject removal is subject to the approval of the ASF board. ## 7 CONTRIBUTORS 7.1 Like all Apache projects, the Apache Xalan project is a meritocracy -- the more work you do, the more you are allowed to do. 7.2 People who make regular and substantial contributions may become committers as described below. Contributions include: participating in mailing lists, reporting issues or bugs in issue-records in the Issue Database, providing patches, and proposing changes to a product. 7.3 In order to ensure that all code contained in the Apache Xalan project's code repository is free of licensing, intellectual property and patent issues, any person wishing to contribute a new feature to Apache Xalan must either sign: a) If contributing as an individual, sign the "Individual Contributor License Agreement (CLA)" ([http://www.apache.org/licenses/icla.txt](http://www.apache.org/licenses/icla.txt)) and file a copy with the Secretary of the Corporation; or b) If making the contribution as part of their employment responsibilities, sign the "Corporate CLA (CCLA)", ([http://www.apache.org/licenses/cla-corporate.txt](http://www.apache.org/licenses/cla-corporate.txt)) and file a copy with the Secretary of the Corporation. 7.4 If the contribution in question is a small bugfix, the contributor need not sign a CLA, but need only provide the following information, attaching it to the communication containing the patch: a) Name and employer b) Are you the author of the code being contributed? c) Do you have the right to grant the copyright and patent licenses for the contribution that are set forth in the ASF v.2.0 license ([http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0))? d) Does your employer have any rights to code that you have written, for example, through your contract for employment? If so, has your employer given you permission to contribute the code on its behalf or waived its rights in the code? e) Are you aware of any third-party licenses or other restrictions (such as related patents or trademarks) that could apply to your contribution? If so, what are they? ## 8 COMMITTERS 8.1 The Apache Xalan project has a set of committers. If there are subprojects, each subproject will also have a set of committers. Committers are contributors who have read/write access to the source code repository. New committers are added when a contributor is nominated by a committer and approved by at least 50 percent of the active committers for that subproject with no opposing votes. In most cases, new committers will already be participating in the development process by submitting suggestions and/or fixes via issue-records in the Issue Database or mailing lists. 8.2 For the purposes of voting, committers will be classed as "active" or "inactive". Only active committers will be included in the totals used to determine the success or failure of a particular vote. 8.3 Committers remain active as long as they are contributing code or posting to the project or subproject mailing lists. If a committers has neither contributed code nor posted to the mailing lists in 3 months, a member of the PMC will e-mail the committer, the project or subproject development list, and the PMC mailing list notifying the committer that they are now in inactive status. 8.4 An inactive status will not prevent a committer committing new code changes or posting to the mailing lists. Either of these activities will automatically re-activate the committer for the purposes of voting. ## 9 INFRASTRUCTURE 9.1 The Apache Xalan project relies on the Apache XML project and the Apache Infrastructure project for the following: a) Issue Database -- This is a system with issue-records, for tracking bugs, issues, features and requests. b) Repository -- The xalan.apache.org project has its set of parts that make up the software, and these parts are managed in a repository. Committers make changes to the source code, documentation and other associated parts that are stored in the repository. Any subproject will have its set of committers for its repository. c) Website -- The website [xalan.apache.org](http://xalan.apache.org) will contain information about the Apache Xalan project and its subprojects, including documentation, downloads of releases, and this charter. d) Mailing Lists -- appropriate mailing lists will be created at the discretion of the PMC. Such mailing lists could for example include: a PMC mailing list, a general mailing list, project or subproject public developer mailing lists, project or subproject public user mailing lists. ## 10 LICENSING 10.1 All contributions to the Apache Xalan project adhere to the "Apache Software Foundation License, Version 2.0" ([http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)). All further contributions, including patches, must be made under the same terms. 10.2 When a committer is considering integrating a contribution from a contributor who has no CLA on file with the Corporation, it is the responsibility of the committer, in consultation with the PMC, to conduct due diligence on the pedigree of the contribution under consideration; see sections 7.3 and 7.4. ## 11 THE DEVELOPMENT PROCESS 11.1 For a committer to commit a change to the MAIN branch of the repository an issue-record must be opened in the "Issue Database" to track the change. The status of the issue must be kept up to date. 11.2 No voting is required to commit changes, but one other active committer must review the changes. Before the changes are committed, the reviewer must add a comment in the corresponding issue-record indicating that they have reviewed and approve the changes. 11.3 Issue-records and reviews are not required for committing changes to other experimental branches (not the MAIN branch) in a repository. ## 12 VOTING 12.1 Unless otherwise stated in this mission, votes cast on Apache Xalan proposals must be made within two weeks of the proposal. A challenge to a proposal must also be made within two weeks of the proposal. Likewise, votes cast on challenges must be cast within two weeks of the challenge. ## 13 RELATIONSHIP TO OTHER APACHE PROJECTS 13.1 The Apache Xalan project should work closely with other Apache projects, such as Xerces and XML, to avoid redundancy and achieve a coherent architecture among Apache Xalan and these projects. xalan_c-1.12/docs/doxygen/footer.html000644 001751 001751 00000001516 13667130245 020435 0ustar00rleighrleigh000000 000000

Copyright © 1999-2020 The Apache Software Foundation. All Rights Reserved.

$generatedby   doxygen $doxygenversion
xalan_c-1.12/docs/doxygen/CMakeLists.txt000644 001751 001751 00000005727 13667130245 021021 0ustar00rleighrleigh000000 000000 # CMake build for xalan-c # # Written by Roger Leigh # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if(BUILD_DOXYGEN) set(DOXYGEN_LOG "${CMAKE_CURRENT_BINARY_DIR}/api.log") set(DOXYGEN_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/api") set(DOXYFILE ${CMAKE_CURRENT_BINARY_DIR}/api.dox) set(DOXYFILE_TEMPLATE ${CMAKE_CURRENT_SOURCE_DIR}/api.dox.in) set(XERCESC_TAGFILE_DEFAULT "xerces-c.tag") set(XERCESC_HTML_DEFAULT "http://xerces.apache.org/xerces-c/apiDocs-3/") set(XERCESC_DOXYGEN_TAGFILE "${XERCESC_TAGFILE_DEFAULT}" CACHE STRING "Tagfile for xerces-c documentation") set(XERCESC_DOXYGEN_HTML_LOCATION "${XERCESC_HTML_DEFAULT}" CACHE STRING "Base directory for xerces-c HTML documentation") if(EXISTS "${XERCESC_DOXYGEN_TAGFILE}") set(DOXYGEN_XERCESC_TAGFILE "${XERCESC_DOXYGEN_TAGFILE}=${XERCESC_DOXYGEN_HTML_LOCATION}") endif() configure_file(${DOXYFILE_TEMPLATE} ${DOXYFILE} @ONLY) add_custom_command(OUTPUT ${DOXYGEN_LOG} COMMAND ${CMAKE_COMMAND} -E remove_directory ${DOXYGEN_OUTPUT_DIR} COMMAND ${CMAKE_COMMAND} -E make_directory ${DOXYGEN_OUTPUT_DIR} COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYFILE} DEPENDS ${DOXYFILE} ${DOC_DEPENDENCIES}) if(NOT TARGET doc-check) add_custom_target(doc-check) endif() add_custom_target(${PROJECT_NAME}-doc-check COMMAND ${CMAKE_COMMAND} -Dlogfile=${DOXYGEN_LOG} -P ${PROJECT_SOURCE_DIR}/cmake/DoxygenCheck.cmake DEPENDS ${DOXYGEN_LOG}) add_dependencies(doc-check ${PROJECT_NAME}-doc-check) set_target_properties(${PROJECT_NAME}-doc-check PROPERTIES FOLDER "Documentation") set_target_properties(doc-check PROPERTIES FOLDER "Documentation") if(NOT TARGET doc-api) add_custom_target(doc-api) endif() add_custom_target(${PROJECT_NAME}-doc-api ALL DEPENDS ${DOXYGEN_LOG} ${PROJECT_NAME}-doc-check) add_dependencies(doc-api ${PROJECT_NAME}-doc-api) set_target_properties(${PROJECT_NAME}-doc-api PROPERTIES FOLDER "Documentation") set_target_properties(doc-api PROPERTIES FOLDER "Documentation") install(DIRECTORY "${DOXYGEN_OUTPUT_DIR}/" DESTINATION "${CMAKE_INSTALL_DOCDIR}/api" COMPONENT "development") endif(BUILD_DOXYGEN) xalan_c-1.12/docs/doxygen/api.dox.in000644 001751 001751 00000332106 13667130245 020145 0ustar00rleighrleigh000000 000000 # Doxyfile 1.8.17 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the configuration # file that follow. The default is UTF-8 which is also the encoding used for all # text before the first occurrence of this tag. Doxygen uses libiconv (or the # iconv built into libc) for the transcoding. See # https://www.gnu.org/software/libiconv/ for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = "Xalan-C++ API Reference" # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = @PROJECT_VERSION@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify a logo or an icon that is included # in the documentation. The maximum height of the logo should not exceed 55 # pixels and the maximum width should not exceed 200 pixels. Doxygen will copy # the logo to the output directory. PROJECT_LOGO = @PROJECT_SOURCE_DIR@/docs/images/xalan-small.svg # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = @DOXYGEN_OUTPUT_DIR@ # If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all generated output in the proper direction. # Possible values are: None, LTR, RTL and Context. # The default value is: None. OUTPUT_TEXT_DIRECTION = None # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = "The $name class" \ "The $name widget" \ "The $name file" \ is \ provides \ specifies \ contains \ represents \ a \ an \ the # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = YES # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = @PROJECT_SOURCE_DIR@/src \ @PROJECT_BINARY_DIR@/src # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = @PROJECT_SOURCE_DIR@/src \ @PROJECT_BINARY_DIR@/src # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = YES # If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line # such as # /*************** # as being the beginning of a Javadoc-style comment "banner". If set to NO, the # Javadoc-style will behave just like regular comments and it will not be # interpreted by doxygen. # The default value is: NO. JAVADOC_BANNER = NO # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new # page for each member. If set to NO, the documentation of a member will be part # of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines (in the resulting output). You can put ^^ in the value part of an # alias to insert a newline as if a physical newline was in the original file. # When you need a literal { or } or , in the value part of an alias you have to # escape them by means of a backslash (\), this can lead to conflicts with the # commands \{ and \} for these it is advised to use the version @{ and @} or use # a double escape (\\{ and \\}) ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice # sources only. Doxygen will then generate output that is more tailored for that # language. For instance, namespaces will be presented as modules, types will be # separated into more groups, etc. # The default value is: NO. OPTIMIZE_OUTPUT_SLICE = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, JavaScript, # Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, # Fortran (fixed format Fortran: FortranFixed, free formatted Fortran: # FortranFree, unknown formatted Fortran: Fortran. In the later case the parser # tries to guess whether the code is fixed or free formatted code, this is the # default for Fortran type files), VHDL, tcl. For instance to make doxygen treat # .inc files as Fortran files (default is PHP), and .f files as C (default is # Fortran), use: inc=Fortran f=C. # # Note: For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See https://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up # to that level are automatically included in the table of contents, even if # they do not have an id attribute. # Note: This feature currently applies only to Markdown headings. # Minimum value: 0, maximum value: 99, default value: 5. # This tag requires that the tag MARKDOWN_SUPPORT is set to YES. TOC_INCLUDE_HEADINGS = 5 # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by putting a % sign in front of the word or # globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # If one adds a struct or class to a group and this option is enabled, then also # any nested class or struct is added to the same group. By default this option # is disabled and one has to add nested compounds explicitly via \ingroup. # The default value is: NO. GROUP_NESTED_COMPOUNDS = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = NO # If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual # methods of a class will be included in the documentation. # The default value is: NO. EXTRACT_PRIV_VIRTUAL = NO # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES, all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = NO # If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined # locally in source files will be included in the documentation. If set to NO, # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. If set to YES, local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO, only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO, these classes will be included in the various overviews. This option # has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # declarations. If set to NO, these declarations will be included in the # documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO, these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES, upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # (including Cygwin) ands Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES, the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will # append additional text to a page's title, such as Class Reference. If set to # YES the compound reference will be hidden. # The default value is: NO. HIDE_COMPOUND_REFERENCE= NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = YES # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO, the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo # list. This list is created by putting \todo commands in the documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test # list. This list is created by putting \test commands in the documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES, the # list will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. See also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = YES # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error (stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO, doxygen will only warn about wrong or incomplete # parameter documentation, but not about the absence of documentation. If # EXTRACT_ALL is set to YES then this flag will automatically be disabled. # The default value is: NO. WARN_NO_PARAMDOC = NO # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when # a warning is encountered. # The default value is: NO. WARN_AS_ERROR = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = @DOXYGEN_LOG@ #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING # Note: If this tag is empty the current directory is searched. INPUT = @PROJECT_SOURCE_DIR@/src \ @PROJECT_BINARY_DIR@/src # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: https://www.gnu.org/software/libiconv/) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # read by doxygen. # # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, # *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment), # *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen # C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f, *.for, *.tcl, *.vhd, # *.vhdl, *.ucf, *.qsf and *.ice. FILE_PATTERNS = *.hpp \ *.h # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = * # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # properly processed by doxygen. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. # # Note that for custom extensions or not directly supported extensions you also # need to set EXTENSION_MAPPING for the extension otherwise the files are not # properly processed by doxygen. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = NO # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # entity all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see https://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the # clang parser (see: http://clang.llvm.org/) for more accurate parsing at the # cost of reduced performance. This can be particularly helpful with template # rich C++ code for which doxygen's built-in parser lacks the necessary type # information. # Note: The availability of this option depends on whether or not doxygen was # generated with the -Duse_libclang=ON option for CMake. # The default value is: NO. CLANG_ASSISTED_PARSING = NO # If clang assisted parsing is enabled you can provide the compiler with command # line options that you would normally use when invoking the compiler. Note that # the include paths will already be set by doxygen for the files and directories # specified with INPUT and INCLUDE_PATH. # This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES. CLANG_OPTIONS = # If clang assisted parsing is enabled you can provide the clang parser with the # path to the compilation database (see: # http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the files # were built. This is equivalent to specifying the "-p" option to a clang tool, # such as clang-check. These options will then be passed to the parser. # Note: The availability of this option depends on whether or not doxygen was # generated with the -Duse_libclang=ON option for CMake. CLANG_DATABASE_PATH = #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = YES # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 3 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = @DOXYGEN_OUTPUT_DIR@ # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. #HTML_HEADER = # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = @CMAKE_CURRENT_SOURCE_DIR@/footer.html #HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined # cascading style sheets that are included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefore more robust against future updates. # Doxygen will copy the style sheet files to the output directory. # Note: The order of the extra style sheet files is of importance (e.g. the last # style sheet in the list overrules the setting of the previous ones in the # list). For an example see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = @PROJECT_SOURCE_DIR@/docs/images/xalan-small.svg \ @PROJECT_SOURCE_DIR@/docs/images/asf-small.svg # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the style sheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # https://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to YES can help to show when doxygen was last run and thus if the # documentation is up to date. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = YES # If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML # documentation will contain a main index with vertical navigation menus that # are dynamically created via JavaScript. If disabled, the navigation index will # consists of multiple levels of tabs that are statically embedded in every HTML # page. Disable this option to support browsers that do not have JavaScript, # like the Qt help browser. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_MENUS = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: https://developer.apple.com/xcode/), introduced with OSX # 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy # genXcode/_index.html for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler (hhc.exe). If non-empty, # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated # (YES) or that it should be included in the master .chm file (NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated # (YES) or a normal table of contents (NO) in the .chm file. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NO # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANSPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands # to create new LaTeX commands to be used in formulas as building blocks. See # the section "Including formulas" for details. FORMULA_MACROFILE = # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # https://www.mathjax.org) which uses client side JavaScript for the rendering # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from https://www.mathjax.org before deployment. # The default value is: https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/ # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , / * ==================================================================== */ #include "httpd.h" #include "http_config.h" #include "http_protocol.h" #include "http_log.h" #include "util_script.h" #include "http_main.h" #include "http_request.h" #include static void xslt_init(server_rec *s, pool *p) { ap_add_version_component("mod_xslt/Xalan/1.0"); } static void xslt_child_init(server_rec *s, pool *p) { XalanInitialize(); } static void xslt_child_exit(server_rec *s, pool *p) { XalanTerminate(1); } typedef struct CONTROL_STRUCT_TAG { request_rec* r; int fHeaderSent; } CONTROL_STRUCT; static CallbackSizeType xalan_output_handler(const char *data, CallbackSizeType length, void *handle) { CONTROL_STRUCT* c = (CONTROL_STRUCT*)handle; if (c->fHeaderSent == 0) { c->fHeaderSent = 1; ap_send_http_header(c->r); } return ap_rwrite(data, length, c->r); } static void xalan_flush_handler(void *handle) { CONTROL_STRUCT* c = (CONTROL_STRUCT*)handle; ap_rflush(c->r); } static int xslt_handler(request_rec *r) { char * mimetype = NULL; char * filename = NULL; char * xmlfilename = NULL; char * xslfilename = NULL; XalanHandle xalan = NULL; int i; int dot_point; int error = DECLINED; CONTROL_STRUCT control_struct = { 0, 0 }; control_struct.r = r; mimetype = ap_pstrcat(r->pool, r->filename, NULL); /* Find the extension without any assumptions on string.h */ dot_point = 0; i = 0; while (mimetype[i] != '\0') { if (mimetype[i] == '.') dot_point = i; ++i; } if (dot_point == 0) { fprintf(stderr, "Unable to find extension of : %s\n", mimetype); r->uri = mimetype; return DECLINED; } filename = ap_pstrndup(r->pool, r->filename,dot_point); xmlfilename = ap_pstrcat(r->pool,filename,".xml",NULL); xslfilename = ap_pstrcat(r->pool,filename,".xsl",NULL); xalan = CreateXalanTransformer(); error = XalanTransformToHandler(xmlfilename, xslfilename, xalan, &control_struct, xalan_output_handler, xalan_flush_handler); if(error) { const char* const msg = XalanGetLastError(xalan); fprintf(stderr,"mod_xslt: %s: %s\n", r->filename, msg); r->uri = filename; return DECLINED; } DeleteXalanTransformer(xalan); return OK; } static const handler_rec xslt_handlers[] = { {"mod_xslt", xslt_handler}, {NULL, NULL} }; module MODULE_VAR_EXPORT xslt_module = { STANDARD_MODULE_STUFF, xslt_init, /* initializer */ NULL, /* create per-directory config structure */ NULL, /* merge per-directory config structures */ NULL, /* create per-server config structure */ NULL, /* merge per-server config structures */ NULL, /* command table */ xslt_handlers, /* handlers */ NULL, /* translate_handler */ NULL, /* check_user_id */ NULL, /* check auth */ NULL, /* check access */ NULL, /* type_checker */ NULL, /* pre-run fixups */ NULL, /* logger */ NULL, /* header parser */ xslt_child_init,/* child_init */ xslt_child_exit,/* child_exit */ NULL /* post read-request */ }; xalan_c-1.12/samples/ApacheModuleXSLT/xslt/apachemod.xsl000644 001751 001751 00000006510 13667130245 024014 0ustar00rleighrleigh000000 000000 <xsl:value-of select="@title"/>

  NOTE:  

 
 
    •    
    xalan_c-1.12/samples/ApacheModuleXSLT/xslt/apachemod.xml000644 001751 001751 00000006324 13667130245 024011 0ustar00rleighrleigh000000 000000

    ApacheModuleXSLT is an Apache Web server module that responds to appropriate URLs by performing transformations and returning the output to the client Web browser. The module responds to a request for a given output file (html or txt as configured below) by applying an xsl stylesheet file with that name to an xml document with the same name. The requested "output file" is created on the fly and returned as a text stream to the client.

    To use this module, do the following:

    1. Add LoadModule and (UNIX only) AddModule entries to the Apache configuration file: httpd.conf.

      Windows: LoadModule mod_xslt xml-xalan\c\Build\Win32\VC6\Release\ApacheModuleXSLT.dll

      UNIX: AddModule mod_xslt.c
              and
              LoadModule mod_xslt usr/lib/mod_xslt.xx

      where xx is the appropriate library suffix for the UNIX platform.

    2. Add a <Location> entry to httpd.conf that indicates where xml/xsl file pairs are to be found, and what target file extensions to recognize. We suggest the following:

      <Location /xslt>
        AddHandler .html
        AddHandler .txt
      </Location>

      This <Location> element instructs the module to respond to requests for xxx.html and xxx.txt files in the in the xslt subdirectory (under the document root; see next item) by applying the xxx.xsl stylesheet to xxx.xml (both in that directory) and returning the transformation result to the browser.

      Note: It is up to the stylesheet to apply the appropriate xsl:output method to the output. Whether the user specifies html or txt is, of itself, immaterial.

    3. Put xml/xsl file pairs in the <Location> subdirectory (xslt in the example)) under the document root directory specified in httpd.conf by the DocumentRoot and <Directory> settings. Alternatively, you can modify these settings to point to xml-xalan/c/samples/ApacheModuleXSLT, which includes an xslt subdirectory with xml/xsl file pairs.

    4. Start the Apache server.

    5. From a Web browser, call the module with a URL as follows:
      http://serverName/xslt/xxx.html
      where serverName is the Apache server (such as www.myServer.com) and xxx is the name of an xml/xsl pair of files (such as foo.xml and foo.xsl) in the xslt subdirectory under the DocumentRoot directory.

      For example,
      http://www.myServer.com/xslt/foo.html
      instructs ApacheModuleXSLT to apply the foo.xsl stylesheet to the foo.xml XML document (both files in the xslt directory under the Apache DocumentRoot directory) and return the transformation result to the browser.
         xalan_c-1.12/samples/ApacheModuleXSLT/xslt/foo.xml000644 001751 001751 00000000133 13667130245 022643 0ustar00rleighrleigh000000 000000

    Hello

         xalan_c-1.12/samples/ApacheModuleXSLT/xslt/foo.xsl000644 001751 001751 00000001612 13667130245 022654 0ustar00rleighrleigh000000 000000 <xsl:value-of select="@title"/>

    xalan_c-1.12/samples/EntityResolver/EntityResolver.cpp000644 001751 001751 00000030334 13667130245 024010 0ustar00rleighrleigh000000 000000 /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "xalanc/Include/PlatformDefinitions.hpp" #include #include #include "xercesc/framework/MemBufInputSource.hpp" #include "xercesc/sax/EntityResolver.hpp" #include "xercesc/util/PlatformUtils.hpp" #include "xercesc/util/XMLEntityResolver.hpp" #include "xercesc/util/XMLResourceIdentifier.hpp" #include "xalanc/XalanTransformer/XalanTransformer.hpp" using xercesc::EntityResolver; using xercesc::InputSource; using xercesc::MemBufInputSource; using xalanc::MemoryManager; using xercesc::XMLEntityResolver; using xercesc::XMLResourceIdentifier; using xalanc::XalanDOMString; using xalanc::XalanTransformer; // This class implements both the EntityResolver and XMLEntityResolver abstract // base classes. It maps three system IDs to three pre-defined entities. One // entity is present in the input XML file, one in the input XSL file, and another // as an argument to the XSLT document() function. class MyEntityResolver : public EntityResolver, public XMLEntityResolver { public: MyEntityResolver( const XalanDOMString& theDocumentEntityFile, const XalanDOMString& theStylesheetEntityFile, const XalanDOMString& theDocumentFunctionEntityFile) : EntityResolver(), XMLEntityResolver(), m_documentEntityFile(theDocumentEntityFile), m_stylesheetEntityFile(theStylesheetEntityFile), m_documentFunctionEntityFile(theDocumentFunctionEntityFile) { } virtual ~MyEntityResolver() { } virtual InputSource* resolveEntity( const XMLCh* const /* publicId */, const XMLCh* const systemId) { if (m_documentEntityFile == systemId) { return new MemBufInputSource( reinterpret_cast(s_documentEntity), s_documentEntityLength, m_documentEntityFile.c_str()); } else if (m_stylesheetEntityFile == systemId) { return new MemBufInputSource( reinterpret_cast(s_stylesheetEntity), s_stylesheetEntityLength, m_stylesheetEntityFile.c_str()); } else if (m_documentFunctionEntityFile == systemId) { return new MemBufInputSource( reinterpret_cast(s_documentFunctionEntity), s_documentFunctionEntityLength, m_documentFunctionEntityFile.c_str()); } else { return 0; } } virtual InputSource* resolveEntity(XMLResourceIdentifier* resourceIdentifier) { assert(resourceIdentifier != 0); if (resourceIdentifier->getResourceIdentifierType() == XMLResourceIdentifier::ExternalEntity) { const XMLCh* const theSystemID = resourceIdentifier->getSystemId(); if (m_documentEntityFile == theSystemID) { return new MemBufInputSource( reinterpret_cast(s_documentEntity), s_documentEntityLength, m_documentEntityFile.c_str()); } else if (m_stylesheetEntityFile == theSystemID) { return new MemBufInputSource( reinterpret_cast(s_stylesheetEntity), s_stylesheetEntityLength, m_stylesheetEntityFile.c_str()); } else if (m_documentFunctionEntityFile == theSystemID) { return new MemBufInputSource( reinterpret_cast(s_documentFunctionEntity), s_documentFunctionEntityLength, m_documentFunctionEntityFile.c_str()); } } return 0; } private: // Not implemented... MyEntityResolver& operator=(const MyEntityResolver&); bool operator==(const MyEntityResolver&) const; const XalanDOMString& m_documentEntityFile; const XalanDOMString& m_stylesheetEntityFile; const XalanDOMString& m_documentFunctionEntityFile; static const char* const s_documentEntity; static const XalanDOMString::size_type s_documentEntityLength; static const char* const s_stylesheetEntity; static const XalanDOMString::size_type s_stylesheetEntityLength; static const char* const s_documentFunctionEntity; static const XalanDOMString::size_type s_documentFunctionEntityLength; }; const char* const MyEntityResolver::s_documentEntity = #if defined(XALAN_NON_ASCII_PLATFORM) "Hello world!"; #else "Hello world!"; #endif const XalanDOMString::size_type MyEntityResolver::s_documentEntityLength = XalanDOMString::length(s_documentEntity); const char* const MyEntityResolver::s_stylesheetEntity = #if defined(XALAN_NON_ASCII_PLATFORM) ""; #else ""; #endif const XalanDOMString::size_type MyEntityResolver::s_stylesheetEntityLength = XalanDOMString::length(s_stylesheetEntity); const char* const MyEntityResolver::s_documentFunctionEntity = #if defined(XALAN_NON_ASCII_PLATFORM) "Hello world from the document() function!"; #else "Hello world from the document() function!"; #endif const XalanDOMString::size_type MyEntityResolver::s_documentFunctionEntityLength = XalanDOMString::length(s_documentFunctionEntity); static int transform( XalanTransformer& theTransformer, const XalanDOMString& theXMLFile, const XalanDOMString& theXSLFile, const char* theOutputFile, bool fUseDOM) { using xalanc::XalanCompiledStylesheet; using xalanc::XalanParsedSource; typedef XalanTransformer::EnsureDestroyCompiledStylesheet EnsureDestroyCompiledStylesheet; typedef XalanTransformer::EnsureDestroyParsedSource EnsureDestroyParsedSource; const XalanCompiledStylesheet* theCompiledStylesheet; int theResult = theTransformer.compileStylesheet(theXSLFile, theCompiledStylesheet); if (theResult != 0) { return theResult; } const EnsureDestroyCompiledStylesheet theStylesheetGuard(theTransformer, theCompiledStylesheet); const XalanParsedSource* theParsedSource; theResult = theTransformer.parseSource(theXMLFile, theParsedSource, fUseDOM); if (theResult != 0) { return theResult; } const EnsureDestroyParsedSource theSourceGuard(theTransformer, theParsedSource); return theTransformer.transform(*theParsedSource, theCompiledStylesheet, theOutputFile); } static int transformWithSourceTree( XalanTransformer& theTransformer, MyEntityResolver& theEntityResolver, const XalanDOMString& theXMLFile, const XalanDOMString& theXSLFile) { theTransformer.setEntityResolver(&theEntityResolver); // Do the transform. int theResult = transform(theTransformer, theXMLFile, theXSLFile, "foo1.out", false); if (theResult == 0) { theTransformer.setXMLEntityResolver(&theEntityResolver); theResult = transform(theTransformer, theXMLFile, theXSLFile, "foo2.out", false); } return theResult; } static int transformWithXercesDOM( XalanTransformer& theTransformer, MyEntityResolver& theEntityResolver, const XalanDOMString& theXMLFile, const XalanDOMString& theXSLFile) { theTransformer.setEntityResolver(&theEntityResolver); // Do the transform. int theResult = transform(theTransformer, theXMLFile, theXSLFile, "foo3.out", true); if (theResult == 0) { theTransformer.setXMLEntityResolver(&theEntityResolver); theResult = transform(theTransformer, theXMLFile, theXSLFile, "foo4.out", true); } return theResult; } int main( int argc, char* /* argv */[]) { using std::cerr; using std::endl; int theResult = 0; if (argc != 1) { cerr << "Usage: EntityResolver" << endl << endl; } else { using xercesc::XMLPlatformUtils; using xercesc::XMLException; // Call the static initializer for Xerces. try { XMLPlatformUtils::Initialize(); } catch (const XMLException& toCatch) { cerr << "Error during Xerces initialization. Error code was " << toCatch.getCode() << "." << endl; theResult = -1; } if (theResult == 0) { // Initialize Xalan. XalanTransformer::initialize(); { // Create a XalanTransformer. XalanTransformer theTransformer; const XalanDOMString theXMLFile("foo.xml"); const XalanDOMString theXSLFile("foo.xsl"); const XalanDOMString theDocumentEntityFile("hello.xml"); const XalanDOMString theStylesheetEntityFile("apply-templates.xml"); const XalanDOMString theDocumentFunctionEntityFile("document.xml"); MyEntityResolver theEntityResolver( theDocumentEntityFile, theStylesheetEntityFile, theDocumentFunctionEntityFile); theResult = transformWithSourceTree( theTransformer, theEntityResolver, theXMLFile, theXSLFile); if (theResult == 0) { theResult = transformWithXercesDOM( theTransformer, theEntityResolver, theXMLFile, theXSLFile); } if(theResult != 0) { cerr << "EntityResolver Error: \n" << theTransformer.getLastError() << endl << endl; } } // Terminate Xalan... XalanTransformer::terminate(); } // Terminate Xerces... XMLPlatformUtils::Terminate(); // Clean up the ICU, if it's integrated... XalanTransformer::ICUCleanUp(); } return theResult; } xalan_c-1.12/samples/EntityResolver/foo.xsl000644 001751 001751 00000000710 13667130245 021614 0ustar00rleighrleigh000000 000000 ]> &apply-templates; xalan_c-1.12/samples/EntityResolver/foo.xml000644 001751 001751 00000000146 13667130245 021611 0ustar00rleighrleigh000000 000000 ]> &hello; xalan_c-1.12/samples/SimpleXPathAPI/foo.xml000644 001751 001751 00000001276 13667130245 021350 0ustar00rleighrleigh000000 000000 Mr. Marston Mr. Bertoni Mr. Leslie Ms. Farmer Ms. Midy Mr. Dick Mr. Boag Mr. Curcuru Mr. Kesselman Mr. Auriemma xalan_c-1.12/samples/SimpleXPathAPI/SimpleXPathAPI.cpp000644 001751 001751 00000012466 13667130245 023302 0ustar00rleighrleigh000000 000000 /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include int main( int argc, char* argv[]) { using std::cerr; using std::cout; using std::endl; int theResult = 0; if (argc != 4) { cerr << "Usage: SimpleXPathAPI XMLFilePath Context XPathExpression" << endl; theResult = -1; } else { using xalanc::XSLException; try { using xercesc::XMLPlatformUtils; using xalanc::XPathEvaluator; XMLPlatformUtils::Initialize(); XPathEvaluator::initialize(); { using xercesc::LocalFileInputSource; using xalanc::XalanDocument; using xalanc::XalanDocumentPrefixResolver; using xalanc::XalanDOMString; using xalanc::XalanNode; using xalanc::XalanSourceTreeInit; using xalanc::XalanSourceTreeDOMSupport; using xalanc::XalanSourceTreeParserLiaison; using xalanc::XObjectPtr; // Initialize the XalanSourceTree subsystem... XalanSourceTreeInit theSourceTreeInit; // We'll use these to parse the XML file. XalanSourceTreeDOMSupport theDOMSupport; XalanSourceTreeParserLiaison theLiaison(theDOMSupport); // Hook the two together... theDOMSupport.setParserLiaison(&theLiaison); const XalanDOMString theFileName(argv[1]); // Create an input source that represents a local file... const LocalFileInputSource theInputSource(theFileName.c_str()); // Parse the document... XalanDocument* const theDocument = theLiaison.parseXMLStream(theInputSource); assert(theDocument != 0); XalanDocumentPrefixResolver thePrefixResolver(theDocument); XPathEvaluator theEvaluator; // OK, let's find the context node... XalanNode* const theContextNode = theEvaluator.selectSingleNode( theDOMSupport, theDocument, XalanDOMString(argv[2]).c_str(), thePrefixResolver); if (theContextNode == 0) { cerr << "Warning -- No nodes matched the location path \"" << argv[2] << "\"." << endl << "Execution cannot continue..." << endl << endl; } else { // OK, let's evaluate the expression... const XObjectPtr theResult( theEvaluator.evaluate( theDOMSupport, theContextNode, XalanDOMString(argv[3]).c_str(), thePrefixResolver)); assert(theResult.null() == false); cout << "The string value of the result is:" << endl << theResult->str(theEvaluator.getExecutionContext()) << endl << endl; } } XPathEvaluator::terminate(); XMLPlatformUtils::Terminate(); } catch(const XSLException& theException) { using xalanc::XalanDOMString; XalanDOMString theError; cerr << "XSL exception: " << theException.defaultFormat(theError) << endl; theResult = -1; } catch(...) { cerr << "Generic exception caught!" << endl; theResult = -1; } } return theResult; }