Upload folder using huggingface_hub

.editorconfig

@@ -0,0 +1,11 @@
+# EditorConfig : http://EditorConfig.org
+
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+tab_width = 8
+
+[Makefile*]
+indent_style = tab

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+/result/** -text
+/test/** -text
+fuzz/defaultwhat.profraw filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,66 @@
+*.exe
+*.o
+*.la
+*.lo
+*.pyc
+
+# Executables
+/xmlcatalog
+/xmllint
+
+# Test executables
+/runsuite
+/runtest
+/runxmlconf
+/testModule
+/testapi
+/testchar
+/testdict
+/testlimits
+/testparser
+/testrecurse
+
+# Tests
+/missing.lst
+/runsuite.log
+/runxmlconf.log
+/test.out
+/xmlconf
+/xstc/Tests
+
+# Generated by build system
+/config.h
+/include/libxml/xmlversion.h
+/libxml-2.0.pc
+/libxml2-config.cmake
+/xml2-config
+
+# Autotools
+.deps
+.libs
+Makefile
+Makefile.in
+/INSTALL
+/aclocal.m4
+/autom4te.cache
+/compile
+/config.guess
+/config.guess~
+/config.h.in
+/config.h.in~
+/config.log
+/config.status
+/config.sub
+/config.sub~
+/configure
+/configure~
+/depcomp
+/install-sh
+/install-sh~
+/libtool
+/ltmain.sh
+/missing
+/m4/libtool.m4
+/m4/lt*.m4
+/py-compile
+/stamp-h1

.gitlab-ci.yml

@@ -0,0 +1,367 @@
+include:
+  - component: "gitlab.gnome.org/GNOME/citemplates/release-service@master"
+    inputs:
+      dist-job-name: "dist"
+      tarball-artifact-path: "${TARBALL_ARTIFACT_PATH}"
+
+install:
+  image: registry.gitlab.gnome.org/gnome/libxml2/docs
+  before_script:
+    - rm -rf libxml2-build
+    - mkdir libxml2-build
+    - ln -s /tests/xmlconf .
+  script:
+    - sh .gitlab-ci/install.sh
+  variables:
+    CFLAGS: "-O2"
+    DOXYGEN_WARN_AS_ERROR: "FAIL_ON_WARNINGS"
+  artifacts:
+    expire_in: 2 hrs
+    paths:
+      - install
+
+.test:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  variables:
+    BASE_CONFIG: "--with-http --with-schematron --with-zlib --with-python"
+  before_script:
+    - rm -rf libxml2-build
+    - mkdir libxml2-build
+    - ln -s /tests/xmlconf .
+  script:
+    - sh .gitlab-ci/test.sh
+
+gcc:
+  extends: .test
+  variables:
+    CFLAGS: "-O2"
+
+gcc:c89:
+  extends: .test
+  variables:
+    CONFIG: "--without-python"
+    CFLAGS: "-O2 -std=c89 -D_XOPEN_SOURCE=600 -Wno-error=unused-function -Wno-error=overlength-strings"
+
+gcc:minimum:
+  extends: .test
+  variables:
+    BASE_CONFIG: "--with-minimum"
+    CFLAGS: "-O2"
+
+gcc:medium:
+  extends: .test
+  variables:
+    BASE_CONFIG: "--with-minimum"
+    CONFIG: "--with-threads --with-tree --with-xpath --with-output --with-html --with-iso8859x --with-valid"
+    CFLAGS: "-O2"
+
+gcc:legacy:
+  extends: .test
+  only:
+    - schedules
+  variables:
+    BASE_CONFIG: "--with-legacy --with-python"
+    CFLAGS: "-O2"
+
+gcc:static:
+  extends: .test
+  variables:
+    CONFIG: "--disable-shared --without-python --without-modules"
+    CFLAGS: "-O2"
+
+clang:asan:
+  extends: .test
+  tags:
+    - asan
+  variables:
+    CONFIG: "--without-python"
+    CC: clang
+    CFLAGS: "-O2 -g -fno-omit-frame-pointer -fsanitize=address,undefined,integer -fno-sanitize-recover=all"
+    UBSAN_OPTIONS: "print_stacktrace=1"
+    ASAN_SYMBOLIZER_PATH: "$CI_PROJECT_DIR/.gitlab-ci/llvm-symbolizer"
+
+clang:msan:
+  extends: .test
+#  only:
+#    - schedules
+  variables:
+    CONFIG: "--without-python --without-zlib"
+    CC: clang
+    CFLAGS: "-O2 -g -fno-omit-frame-pointer -fsanitize=memory"
+    MSAN_SYMBOLIZER_PATH: "$CI_PROJECT_DIR/.gitlab-ci/llvm-symbolizer"
+
+.mingw:
+  tags:
+    - win32-ps
+  variables:
+    BASE_CONFIG: "--with-http --with-schematron --with-zlib --with-python"
+    # Python is disabled for now, see #658
+    CONFIG: "--with-docs --without-python"
+    CHERE_INVOKING: "yes"
+  before_script:
+    - $Env:Path="C:\msys64\usr\bin;$Env:Path"
+    - bash -lc 'sh .gitlab-ci/setup_mingw.sh autotools'
+  script:
+    - bash -lc 'sh .gitlab-ci/test.sh'
+  cache:
+    key: "$MSYSTEM"
+    paths:
+      - xmlconf/
+
+mingw:w64-x86_64:shared:
+  extends: .mingw
+  variables:
+    CFLAGS: "-O2"
+    MSYSTEM: MINGW64
+
+mingw:w64-i686:shared:
+  extends: .mingw
+  only:
+    - schedules
+  variables:
+    CFLAGS: "-O2"
+    MSYSTEM: MINGW32
+
+# Disabled, GCC missing?
+.mingw:msys:shared:
+  extends: .mingw
+  variables:
+    CFLAGS: "-O2"
+    MSYSTEM: MSYS
+
+.cmake:linux:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  before_script:
+    - rm -rf libxml2-build
+    - mkdir libxml2-build
+    - ln -s /tests/xmlconf .
+  script:
+    - sh .gitlab-ci/test_cmake.sh
+  artifacts:
+    paths:
+      - libxml2-$CI_COMMIT_SHORT_SHA-$SUFFIX.tar.gz
+    expire_in: 1 day
+
+cmake:linux:gcc:shared:
+  extends: .cmake:linux
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    CONFIG: "-DLIBXML2_WITH_DOCS=ON"
+    CC: gcc
+    SUFFIX: linux-gcc-shared
+
+cmake:linux:gcc:static:
+  extends: .cmake:linux
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    CC: gcc
+    SUFFIX: linux-gcc-static
+
+cmake:linux:clang:shared:
+  extends: .cmake:linux
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    CC: clang
+    SUFFIX: linux-clang-shared
+
+cmake:linux:clang:static:
+  extends: .cmake:linux
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    CC: clang
+    SUFFIX: linux-clang-static
+
+.cmake:mingw:
+  tags:
+    - win32-ps
+  variables:
+    CHERE_INVOKING: "yes"
+  before_script:
+    - $Env:Path="C:\msys64\usr\bin;$Env:Path"
+    - bash -lc 'sh .gitlab-ci/setup_mingw.sh cmake ninja'
+  script:
+    - bash -lc 'sh .gitlab-ci/test_cmake.sh -G Ninja'
+  cache:
+    key: "$MSYSTEM"
+    paths:
+      - xmlconf/
+  artifacts:
+    paths:
+      - libxml2-$Env:CI_COMMIT_SHORT_SHA-$Env:SUFFIX.tar.gz
+    expire_in: 1 day
+
+cmake:mingw:w64-i686:shared:
+  extends: .cmake:mingw
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    CONFIG: "-DLIBXML2_WITH_DOCS=ON"
+    MSYSTEM: MINGW32
+    SUFFIX: mingw-w64-i686-shared
+
+cmake:mingw:w64-i686:static:
+  extends: .cmake:mingw
+#  only:
+#    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    MSYSTEM: MINGW32
+    SUFFIX: mingw-w64-i686-static
+
+cmake:mingw:w64-x86_64:shared:
+  extends: .cmake:mingw
+#  only:
+#    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    MSYSTEM: MINGW64
+    SUFFIX: mingw-w64-x86_64-shared
+
+cmake:mingw:w64-x86_64:static:
+  extends: .cmake:mingw
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    MSYSTEM: MINGW64
+    SUFFIX: mingw-w64-x86_64-static
+
+.cmake:msvc:
+  tags:
+    - win32-ps
+  variables:
+    # MSVC warns when casting `const char **` to `void *` which is wrong.
+    # Disable warning C4090.
+    CFLAGS: /WX /wd4090
+    CMAKE_VERSION: 3.19.4
+  script:
+    - .gitlab-ci/Test-Msvc
+  cache:
+    key: "msvc"
+    paths:
+      - cmake-$Env:CMAKE_VERSION-win64-x64/
+      - xmlconf/
+      - 7za.exe
+  artifacts:
+    paths:
+      - libxml2-$Env:CI_COMMIT_SHORT_SHA-$Env:CMAKE_GENERATOR_TOOLSET-$Env:CMAKE_GENERATOR_PLATFORM-$Env:SUFFIX.7z
+    expire_in: 1 day
+
+.cmake:msvc:v141:
+  extends: .cmake:msvc
+  variables:
+    CMAKE_GENERATOR: Visual Studio 15 2017
+    CMAKE_GENERATOR_TOOLSET: v141
+
+.cmake:msvc:v141:x64:
+  extends: .cmake:msvc:v141
+  variables:
+    CMAKE_GENERATOR_PLATFORM: x64
+
+cmake:msvc:v141:x64:shared:
+  extends: .cmake:msvc:v141:x64
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    SUFFIX: shared
+
+cmake:msvc:v141:x64:static:
+  extends: .cmake:msvc:v141:x64
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    SUFFIX: static
+
+.cmake:msvc:v141:x86:
+  extends: .cmake:msvc:v141
+  only:
+    - schedules
+  variables:
+    CMAKE_GENERATOR_PLATFORM: Win32
+
+cmake:msvc:v141:x86:shared:
+  extends: .cmake:msvc:v141:x86
+  only:
+    - schedules
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    SUFFIX: shared
+
+cmake:msvc:v141:x86:static:
+  extends: .cmake:msvc:v141:x86
+  variables:
+    BUILD_SHARED_LIBS: "OFF"
+    SUFFIX: static
+
+meson:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  before_script:
+    - ln -s /tests/xmlconf .
+  script:
+    - sh .gitlab-ci/test_meson.sh
+
+cmake:linux:gcc:shared:
+  extends: .cmake:linux
+  variables:
+    BUILD_SHARED_LIBS: "ON"
+    CC: gcc
+    SUFFIX: linux-gcc-shared
+
+dist:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  script:
+    - sh .gitlab-ci/dist.sh
+    - echo "TARBALL_ARTIFACT_PATH=$(ls libxml2-dist/*.tar.xz)" >> build.env
+  artifacts:
+    paths:
+      - libxml2-dist/*.tar.xz
+    reports:
+      dotenv: build.env
+
+pages:
+  needs: [install]
+  script:
+    - cp -r install/share/doc/libxml2 public
+    - cp doc/_redirects public
+  artifacts:
+    paths:
+      - public
+  only:
+    - master@GNOME/libxml2
+
+downstream-lxml:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  needs: [install]
+  script:
+    - sh .gitlab-ci/downstream-lxml.sh
+
+downstream-nokogiri:
+  # owner: @flavorjones
+  image: ghcr.io/sparklemotion/nokogiri-test:upstream-libxml
+  script:
+    - .gitlab-ci/downstream-nokogiri.sh
+
+downstream-perl:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  needs: [install]
+  script:
+    - sh .gitlab-ci/downstream-perl.sh
+
+downstream-php:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  needs: [install]
+  script:
+    - sh .gitlab-ci/downstream-php.sh
+
+downstream-xmlstarlet:
+  image: registry.gitlab.gnome.org/gnome/libxml2
+  needs: [install]
+  script:
+    - sh .gitlab-ci/downstream-xmlstarlet.sh

.gitlab-ci/Dockerfile

@@ -0,0 +1,56 @@
+# The image is also used for libxslt.
+#
+# package           required for
+# ------------------------------------------------------------
+# libclang-rt-dev   sanitizer runtimes
+# llvm              llvm-symbolizer (for sanitizer backtraces)
+# git               libxslt, downstream projects
+# libgcrypt-dev     libxslt
+# xz-utils          make dist
+# doxygen           documentation
+# xsltproc          documentation
+# docbook-xsl       documentation
+
+FROM ubuntu:24.04
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && \
+    apt-get upgrade -y && \
+    apt-get install -y --no-install-recommends \
+        curl git ca-certificates \
+        autoconf automake libtool pkg-config \
+        make gcc clang llvm libclang-rt-dev \
+        zlib1g-dev libgcrypt-dev \
+        python3-dev \
+        cmake meson \
+        xz-utils \
+        doxygen xsltproc docbook-xsl
+WORKDIR /tests
+RUN curl https://www.w3.org/XML/Test/xmlts20080827.tar.gz |tar xz
+
+# XML::LibXML uses Alien::Libxml2 which has a huge dependency chain.
+# We try to install most dependencies with apt. We also require
+# libxml2-dev to stop Alien::Libxml2 from downloading and building
+# libxml2 on its own.
+RUN apt-get install -y --no-install-recommends \
+        libperl-dev libxml2-dev cpanminus \
+        libalien-build-perl \
+        libio-socket-ssl-perl \
+        libsort-versions-perl \
+        liburi-perl \
+        libxml-namespacesupport-perl  \
+        libxml-sax-perl \
+        libyaml-perl
+RUN cpanm -n Alien::Libxml2
+RUN apt-get remove -y libxml2-dev
+
+# PHP
+RUN apt-get install -y --no-install-recommends \
+        bison re2c libsqlite3-dev
+
+# lxml
+RUN apt-get install -y --no-install-recommends \
+        cython3
+
+# xmlstarlet
+RUN apt-get install -y --no-install-recommends \
+        docbook-xsl-ns

.gitlab-ci/Dockerfile.docs

@@ -0,0 +1,5 @@
+# Image used to generate documentation with a recent version of Doxygen.
+# 1.14.0 fixes an important bug.
+
+FROM archlinux:base-devel
+RUN pacman -Syu --noconfirm doxygen libxslt docbook-xsl git

.gitlab-ci/Test-Msvc.ps1

@@ -0,0 +1,46 @@
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+
+if (-not (Test-Path 7za.exe)) {
+    Invoke-WebRequest `
+        -Uri https://www.7-zip.org/a/7z1900-extra.7z `
+        -OutFile 7z1900-extra.7z
+    cmake -E tar xf 7z1900-extra.7z 7za.exe
+}
+
+if (-not (Test-Path xmlconf)) {
+    Invoke-WebRequest `
+        -Uri https://www.w3.org/XML/Test/xmlts20080827.tar.gz `
+        -OutFile xmlts20080827.tar.gz ;
+    .\7za.exe x xmlts20080827.tar.gz
+    .\7za.exe x xmlts20080827.tar
+}
+
+cmake `
+    -G "Visual Studio 16 2019" `
+    -DBUILD_SHARED_LIBS="$Env:BUILD_SHARED_LIBS" `
+    -DCMAKE_INSTALL_PREFIX=libxml2-install `
+    -DLIBXML2_WITH_SCHEMATRON=ON `
+    -DLIBXML2_WITH_ICONV=OFF `
+    -DLIBXML2_WITH_PYTHON=OFF `
+    -DLIBXML2_WITH_ZLIB=OFF `
+    -S . -B libxml2-build
+if ($LastExitCode -ne 0) {
+    throw "cmake failed"
+}
+cmake --build libxml2-build --config Debug --target install
+cmake --build libxml2-build --config Release --target install
+New-Item -ItemType Directory libxml2-install\share\libxml2
+Copy-Item Copyright libxml2-install\share\libxml2
+
+cd libxml2-build
+ctest -C Debug -VV
+if ($LastExitCode -ne 0) {
+    throw "ctest failed"
+}
+ctest -C Release -VV
+if ($LastExitCode -ne 0) {
+    throw "ctest failed"
+}
+cd ..
+
+.\7za.exe a libxml2-$Env:CI_COMMIT_SHORT_SHA-$Env:CMAKE_GENERATOR_TOOLSET-$Env:CMAKE_GENERATOR_PLATFORM-$Env:SUFFIX.7z .\libxml2-install\*

.gitlab-ci/dist.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+
+set -e
+
+mkdir -p libxml2-dist
+cd libxml2-dist
+sh ../autogen.sh
+make distcheck V=1 DISTCHECK_CONFIGURE_FLAGS='--with-docs --with-legacy'
+if [ -z "$CI_COMMIT_TAG" ]; then
+    mv libxml2-*.tar.xz libxml2-git-$CI_COMMIT_SHORT_SHA.tar.xz
+fi

.gitlab-ci/downstream-lxml.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+set -e
+
+srcdir=$(pwd)
+installdir="$srcdir/install"
+export PKG_CONFIG_PATH="$installdir/lib/pkgconfig"
+
+git clone --depth 1 https://github.com/lxml/lxml.git
+cd lxml
+make
+LD_LIBRARY_PATH="$installdir/lib" make TESTFLAGS='' test

.gitlab-ci/downstream-nokogiri.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+set -e
+
+export LIBXML_DIR=$(pwd)
+export MAKEFLAGS=-j$(nproc)
+export NOCONFIGURE=1
+./autogen.sh
+
+git clone https://github.com/sparklemotion/nokogiri
+cd nokogiri
+bundle install
+bundle exec rake compile -- --with-xml2-source-dir=${LIBXML_DIR}
+bundle exec rake test

.gitlab-ci/downstream-perl.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+set -e
+
+srcdir=$(pwd)
+installdir="$srcdir/install"
+incdir="$installdir/include/libxml2"
+libdir="$installdir/lib"
+
+git clone --depth 1 -b test-suite-libxml2 \
+    https://github.com/nwellnhof/perl-XML-LibXML.git
+cd perl-XML-LibXML
+
+perl Makefile.PL INC="-I$incdir" LIBS="-L$libdir -lxml2"
+make
+make test

.gitlab-ci/downstream-php.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+
+set -e
+
+srcdir=$(pwd)
+installdir="$srcdir/install"
+export PKG_CONFIG_PATH="$installdir/lib/pkgconfig"
+
+git clone --depth 1 https://github.com/php/php-src.git
+cd php-src
+./buildconf
+./configure --with-xsl --enable-soap --enable-debug
+make -j$(nproc)
+make TESTS=" \
+    -g FAIL \
+    --show-diff \
+    --no-progress \
+    ext/dom \
+    ext/libxml \
+    ext/simplexml \
+    ext/soap \
+    ext/xml \
+    ext/xmlreader \
+    ext/xmlwriter \
+    ext/xsl \
+" test

.gitlab-ci/downstream-xmlstarlet.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -e
+
+srcdir=$(pwd)
+installdir="$srcdir/install"
+# xmlstarlet uses xml2-config
+export PATH="$installdir/bin:$PATH"
+
+# We can't use --depth 1 because configure calls git-describe
+# which needs the branch history.
+git clone --single-branch https://github.com/nwellnhof/xmlstar.git
+cd xmlstar
+autoreconf -sif
+./configure
+make
+LD_LIBRARY_PATH="$installdir/lib" make check

.gitlab-ci/install.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+
+set -e
+
+srcdir=$(pwd)
+
+mkdir -p install
+installdir="$srcdir/install"
+export PKG_CONFIG_PATH="$installdir/lib/pkgconfig"
+
+sh autogen.sh "--prefix=$installdir" --with-docs --with-schematron --with-zlib
+make -j$(nproc)
+make install
+
+# Make system XML catalog available
+ln -s /etc install/etc
+
+git clone --depth 1 https://gitlab.gnome.org/GNOME/libxslt.git
+cd libxslt
+sh autogen.sh \
+    "--prefix=$installdir" \
+    --without-python
+make -j$(nproc)
+make install

.gitlab-ci/llvm-symbolizer

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# Newer versions of llvm-symbolizer require libxml2 themselves. Running
+# a test program with LD_LIBRARY_PATH set to .libs makes llvm-symbolizer
+# pick up the tested development version of libxml2 which breaks
+# completely if the build is instrumented with ASan. This wrapper script
+# invokes llvm-symbolizer with an empty LD_LIBRARY_PATH.
+
+LD_LIBRARY_PATH='' llvm-symbolizer "$@"

.gitlab-ci/setup_mingw.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+pacman --noconfirm -Syu
+
+prefix=
+if [ -n "$MINGW_PACKAGE_PREFIX" ]; then
+    prefix="${MINGW_PACKAGE_PREFIX}-"
+fi
+for module in docbook-xsl doxygen libiconv python xsltproc xz zlib "$@"; do
+    pacman --noconfirm -S --needed ${prefix}$module
+done
+
+mkdir -p libxml2-build
+
+if [ ! -e xmlconf ]; then
+    wget https://www.w3.org/XML/Test/xmlts20080827.tar -O - |
+       tar -x
+fi

.gitlab-ci/test.sh

@@ -0,0 +1,8 @@
+#!/bin/sh
+
+set -e
+
+cd libxml2-build
+sh ../autogen.sh $BASE_CONFIG $CONFIG || cat config.log
+make -j$(nproc) V=1 CFLAGS="$CFLAGS -Werror"
+make CFLAGS="$CFLAGS -Werror" check

.gitlab-ci/test_cmake.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -e
+
+CFLAGS="-Werror $CFLAGS" \
+cmake "$@" \
+    -DBUILD_SHARED_LIBS=$BUILD_SHARED_LIBS \
+    -DCMAKE_INSTALL_PREFIX=libxml2-install \
+    -DCMAKE_BUILD_TYPE=RelWithDebInfo \
+    -DLIBXML2_WITH_HTTP=ON \
+    -DLIBXML2_WITH_SCHEMATRON=ON \
+    -DLIBXML2_WITH_ZLIB=ON \
+    -DLIBXML2_WITH_PYTHON=ON \
+    $CONFIG \
+    -S . -B libxml2-build
+cmake --build libxml2-build --target install
+
+(cd libxml2-build && ctest -VV)
+
+mkdir -p libxml2-install/share/libxml2
+cp Copyright libxml2-install/share/libxml2
+(cd libxml2-install &&
+    tar -czf ../libxml2-$CI_COMMIT_SHORT_SHA-$SUFFIX.tar.gz *)

.gitlab-ci/test_meson.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -e
+
+# compile with the following warnings:
+# --warnlevel 3     : passes to the compiler -Wall -Wextra -Wpedantic
+# --werror          : passes to the compiler -Werror
+# --default-library : can be 'shared', 'static' or 'both'
+meson  setup \
+       --warnlevel 3 \
+       --werror \
+       --buildtype=debugoptimized \
+       --default-library shared \
+       -Ddocs=enabled \
+       -Dhttp=enabled \
+       -Dschematron=enabled \
+       -Dzlib=enabled \
+       -Dpython=enabled \
+       builddir
+
+ninja -C builddir
+
+meson test --verbose -C builddir

CMakeLists.txt

@@ -0,0 +1,747 @@
+cmake_minimum_required(VERSION 3.18)
+
+file(READ "VERSION" VERSION)
+string(STRIP ${VERSION} VERSION)
+if(${VERSION} MATCHES [[([0-9]+)\.([0-9]+)\.([0-9]+)]])
+    set(LIBXML_MAJOR_VERSION ${CMAKE_MATCH_1})
+    set(LIBXML_MINOR_VERSION ${CMAKE_MATCH_2})
+    set(LIBXML_MICRO_VERSION ${CMAKE_MATCH_3})
+endif()
+
+project(libxml2 VERSION ${VERSION} LANGUAGES C)
+
+set(CMAKE_C_STANDARD 11)
+
+include(CheckCSourceCompiles)
+include(CheckFunctionExists)
+include(CheckIncludeFiles)
+include(CheckLibraryExists)
+include(CheckStructHasMember)
+include(CheckSymbolExists)
+include(CMakeDependentOption)
+include(CMakePackageConfigHelpers)
+include(CMakePushCheckState)
+include(FindPkgConfig)
+include(GNUInstallDirs)
+
+option(BUILD_SHARED_LIBS "Build shared libraries" ON)
+option(LIBXML2_WITH_CATALOG "Add the Catalog support" ON)
+option(LIBXML2_WITH_DEBUG "Add the debugging module" ON)
+option(LIBXML2_WITH_DOCS "Build documentation" OFF)
+option(LIBXML2_WITH_HTML "Add the HTML support" ON)
+option(LIBXML2_WITH_HTTP "ABI compatibility for removed HTTP support" OFF)
+option(LIBXML2_WITH_ICONV "Add ICONV support" ON)
+option(LIBXML2_WITH_ICU "Add ICU support" OFF)
+option(LIBXML2_WITH_ISO8859X "Add ISO8859X support if no iconv" ON)
+option(LIBXML2_WITH_LEGACY "Add deprecated APIs for compatibility" OFF)
+option(LIBXML2_WITH_MODULES "Add the dynamic modules support" ON)
+option(LIBXML2_WITH_OUTPUT "Add the serialization support" ON)
+option(LIBXML2_WITH_PATTERN "Add the xmlPattern selection interface" ON)
+option(LIBXML2_WITH_PROGRAMS "Build programs" ON)
+option(LIBXML2_WITH_PUSH "Add the PUSH parser interfaces" ON)
+option(LIBXML2_WITH_PYTHON "Build Python bindings" OFF)
+option(LIBXML2_WITH_READLINE "readline support for xmllint shell" OFF)
+option(LIBXML2_WITH_REGEXPS "Add Regular Expressions support" ON)
+option(LIBXML2_WITH_SAX1 "Add the older SAX1 interface" ON)
+option(LIBXML2_WITH_TESTS "Build tests" ON)
+option(LIBXML2_WITH_THREADS "Add multithread support" ON)
+option(LIBXML2_WITH_TLS "Enable thread-local storage" OFF)
+option(LIBXML2_WITH_VALID "Add the DTD validation support" ON)
+option(LIBXML2_WITH_XINCLUDE "Add the XInclude support" ON)
+option(LIBXML2_WITH_XPATH "Add the XPATH support" ON)
+
+cmake_dependent_option(
+    LIBXML2_WITH_ZLIB "Use libz" OFF
+    "NOT LIBXML2_WITH_LEGACY" ON)
+
+cmake_dependent_option(
+    LIBXML2_WITH_C14N "Add the Canonicalization support" ON
+    "LIBXML2_WITH_OUTPUT;LIBXML2_WITH_XPATH" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_HISTORY "history support for xmllint shell" OFF
+    "LIBXML2_WITH_READLINE" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_READER "Add the xmlReader parsing interface" ON
+    "LIBXML2_WITH_PUSH" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_SCHEMAS "Add XML Schemas 1.0 support" ON
+    "LIBXML2_WITH_PATTERN;LIBXML2_WITH_REGEXPS" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_SCHEMATRON "Add Schematron support" OFF
+    "LIBXML2_WITH_PATTERN;LIBXML2_WITH_XPATH" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_THREAD_ALLOC "Add per-thread malloc hooks" OFF
+    "LIBXML2_WITH_THREADS" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_WRITER "Add the xmlWriter saving interface" ON
+    "LIBXML2_WITH_OUTPUT;LIBXML2_WITH_PUSH" OFF)
+cmake_dependent_option(
+    LIBXML2_WITH_XPTR "Add the XPointer support" ON
+    "LIBXML2_WITH_XPATH" OFF)
+
+cmake_dependent_option(
+    LIBXML2_WITH_RELAXNG "Add Relax-NG support" ON
+    "LIBXML2_WITH_REGEXPS;LIBXML2_WITH_SCHEMAS" OFF)
+
+if(LIBXML2_WITH_PYTHON)
+    find_package(Python3 COMPONENTS Interpreter Development REQUIRED)
+    #set(LIBXML2_PYTHON_INSTALL_DIR ${Python3_SITEARCH} CACHE PATH "Python bindings install directory")
+    set(LIBXML2_PYTHON_INSTALL_DIR "${CMAKE_INSTALL_PREFIX}/python"
+        CACHE PATH "Python bindings install directory")
+endif()
+
+foreach(VARIABLE IN ITEMS WITH_C14N WITH_CATALOG WITH_DEBUG WITH_HTML WITH_HTTP WITH_ICONV WITH_ICU WITH_ISO8859X WITH_MODULES WITH_OUTPUT WITH_PATTERN WITH_PUSH WITH_READER WITH_REGEXPS WITH_RELAXNG WITH_SAX1 WITH_SCHEMAS WITH_SCHEMATRON WITH_THREADS WITH_THREAD_ALLOC WITH_VALID WITH_WRITER WITH_XINCLUDE WITH_XPATH WITH_XPTR WITH_ZLIB)
+    if(LIBXML2_${VARIABLE})
+        set(${VARIABLE} 1)
+    else()
+        set(${VARIABLE} 0)
+    endif()
+endforeach()
+
+set(LIBXML_VERSION ${VERSION})
+set(LIBXML_VERSION_EXTRA "")
+math(EXPR LIBXML_VERSION_NUMBER "
+    ${LIBXML_MAJOR_VERSION} * 10000 +
+    ${LIBXML_MINOR_VERSION} * 100 +
+    ${LIBXML_MICRO_VERSION}
+")
+
+set(MODULE_EXTENSION "${CMAKE_SHARED_LIBRARY_SUFFIX}")
+
+if(LIBXML2_WITH_ICONV)
+    find_package(Iconv REQUIRED)
+endif()
+
+if(LIBXML2_WITH_ICU)
+    find_package(ICU REQUIRED COMPONENTS uc)
+endif()
+
+if(LIBXML2_WITH_THREADS)
+    find_package(Threads REQUIRED)
+    set(THREAD_LIBS ${CMAKE_THREAD_LIBS_INIT})
+    list(APPEND CMAKE_REQUIRED_LIBRARIES Threads::Threads)
+endif()
+
+if(LIBXML2_WITH_ZLIB)
+    find_package(ZLIB REQUIRED)
+endif()
+
+check_c_source_compiles("
+    void __attribute__((destructor))
+    f(void) {}
+    int main(void) { return 0; }
+" HAVE_FUNC_ATTRIBUTE_DESTRUCTOR)
+check_symbol_exists(getentropy "sys/random.h" HAVE_DECL_GETENTROPY)
+check_symbol_exists(glob "glob.h" HAVE_DECL_GLOB)
+check_symbol_exists(mmap "sys/mman.h" HAVE_DECL_MMAP)
+check_include_files(stdint.h HAVE_STDINT_H)
+
+if(LIBXML2_WITH_READLINE)
+    check_library_exists(readline readline "" HAVE_LIBREADLINE)
+    if (LIBXML2_WITH_HISTORY)
+        check_library_exists(history append_history "" HAVE_LIBHISTORY)
+    endif()
+endif()
+
+if(LIBXML2_WITH_TLS)
+    check_c_source_compiles(
+        "_Thread_local int v; int main(){return 0;}"
+        XML_THREAD_LOCAL_C11
+    )
+    if (XML_THREAD_LOCAL_C11)
+        set(XML_THREAD_LOCAL "_Thread_local")
+    else()
+        check_c_source_compiles(
+            "__thread int v; int main(){return 0;}"
+            XML_THREAD_LOCAL_THREAD
+        )
+        if (XML_THREAD_LOCAL_THREAD)
+            set(XML_THREAD_LOCAL "__thread")
+        else()
+            check_c_source_compiles(
+                "__declspec(thread) int v; int main(){return 0;}"
+                XML_THREAD_LOCAL_DECLSPEC
+            )
+            if (XML_THREAD_LOCAL_DECLSPEC)
+                set(XML_THREAD_LOCAL "__declspec(thread)")
+            endif()
+        endif()
+    endif()
+endif()
+
+set(
+    LIBXML2_HDRS
+    include/libxml/c14n.h
+    include/libxml/catalog.h
+    include/libxml/chvalid.h
+    include/libxml/debugXML.h
+    include/libxml/dict.h
+    include/libxml/encoding.h
+    include/libxml/entities.h
+    include/libxml/globals.h
+    include/libxml/hash.h
+    include/libxml/HTMLparser.h
+    include/libxml/HTMLtree.h
+    include/libxml/list.h
+    include/libxml/nanoftp.h
+    include/libxml/nanohttp.h
+    include/libxml/parser.h
+    include/libxml/parserInternals.h
+    include/libxml/pattern.h
+    include/libxml/relaxng.h
+    include/libxml/SAX.h
+    include/libxml/SAX2.h
+    include/libxml/schemasInternals.h
+    include/libxml/schematron.h
+    include/libxml/threads.h
+    include/libxml/tree.h
+    include/libxml/uri.h
+    include/libxml/valid.h
+    include/libxml/xinclude.h
+    include/libxml/xlink.h
+    include/libxml/xmlIO.h
+    include/libxml/xmlautomata.h
+    include/libxml/xmlerror.h
+    include/libxml/xmlexports.h
+    include/libxml/xmlmemory.h
+    include/libxml/xmlmodule.h
+    include/libxml/xmlreader.h
+    include/libxml/xmlregexp.h
+    include/libxml/xmlsave.h
+    include/libxml/xmlschemas.h
+    include/libxml/xmlschemastypes.h
+    include/libxml/xmlstring.h
+    include/libxml/xmlunicode.h
+    include/libxml/xmlwriter.h
+    include/libxml/xpath.h
+    include/libxml/xpathInternals.h
+    include/libxml/xpointer.h
+)
+
+set(
+    LIBXML2_SRCS
+    buf.c
+    chvalid.c
+    dict.c
+    encoding.c
+    entities.c
+    error.c
+    globals.c
+    hash.c
+    list.c
+    parser.c
+    parserInternals.c
+    SAX2.c
+    threads.c
+    tree.c
+    uri.c
+    valid.c
+    xmlIO.c
+    xmlmemory.c
+    xmlstring.c
+)
+if(LIBXML2_WITH_C14N)
+    list(APPEND LIBXML2_SRCS c14n.c)
+endif()
+if(LIBXML2_WITH_CATALOG)
+    list(APPEND LIBXML2_SRCS catalog.c)
+endif()
+if(LIBXML2_WITH_DEBUG)
+    list(APPEND LIBXML2_SRCS debugXML.c)
+endif()
+if(LIBXML2_WITH_HTML)
+    list(APPEND LIBXML2_SRCS HTMLparser.c HTMLtree.c)
+endif()
+if(LIBXML2_WITH_HTTP)
+    list(APPEND LIBXML2_SRCS nanohttp.c)
+endif()
+if(LIBXML2_WITH_MODULES)
+    list(APPEND LIBXML2_SRCS xmlmodule.c)
+endif()
+if(LIBXML2_WITH_OUTPUT)
+    list(APPEND LIBXML2_SRCS xmlsave.c)
+endif()
+if(LIBXML2_WITH_PATTERN)
+    list(APPEND LIBXML2_SRCS pattern.c)
+endif()
+if(LIBXML2_WITH_READER)
+    list(APPEND LIBXML2_SRCS xmlreader.c)
+endif()
+if(LIBXML2_WITH_REGEXPS)
+    list(APPEND LIBXML2_SRCS xmlregexp.c)
+endif()
+if(LIBXML2_WITH_RELAXNG)
+    list(APPEND LIBXML2_SRCS relaxng.c)
+endif()
+if(LIBXML2_WITH_SCHEMAS)
+    list(APPEND LIBXML2_SRCS xmlschemas.c xmlschemastypes.c)
+endif()
+if(LIBXML2_WITH_SCHEMATRON)
+    list(APPEND LIBXML2_SRCS schematron.c)
+endif()
+if(LIBXML2_WITH_WRITER)
+    list(APPEND LIBXML2_SRCS xmlwriter.c)
+endif()
+if(LIBXML2_WITH_XINCLUDE)
+    list(APPEND LIBXML2_SRCS xinclude.c)
+endif()
+if(LIBXML2_WITH_XPATH)
+    list(APPEND LIBXML2_SRCS xpath.c)
+endif()
+if(LIBXML2_WITH_XPTR)
+    list(APPEND LIBXML2_SRCS xlink.c xpointer.c)
+endif()
+
+if(WIN32)
+    list(APPEND LIBXML2_SRCS win32/libxml2.rc)
+    file(
+        WRITE
+        ${CMAKE_CURRENT_BINARY_DIR}/rcVersion.h
+        "#define LIBXML_MAJOR_VERSION ${LIBXML_MAJOR_VERSION}\n"
+        "#define LIBXML_MINOR_VERSION ${LIBXML_MINOR_VERSION}\n"
+        "#define LIBXML_MICRO_VERSION ${LIBXML_MICRO_VERSION}\n"
+        "#define LIBXML_DOTTED_VERSION \"${VERSION}\"\n"
+    )
+endif()
+
+add_library(LibXml2 ${LIBXML2_HDRS} ${LIBXML2_SRCS})
+add_library(LibXml2::LibXml2 ALIAS LibXml2)
+
+target_include_directories(
+    LibXml2
+    PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:$<INSTALL_PREFIX>/${CMAKE_INSTALL_INCLUDEDIR}/libxml2>
+)
+
+if(LIBXML2_WITH_MODULES)
+    cmake_push_check_state(RESET)
+        set(CMAKE_REQUIRED_LIBRARIES ${CMAKE_DL_LIBS})
+        check_symbol_exists(dlopen "dlfcn.h" HAVE_DLOPEN)
+    cmake_pop_check_state()
+    if(HAVE_DLOPEN)
+        target_link_libraries(LibXml2 PRIVATE ${CMAKE_DL_LIBS})
+        list(TRANSFORM CMAKE_DL_LIBS PREPEND "-l" REGEX "^[^-]" OUTPUT_VARIABLE MODULE_LIBS)
+    else()
+        check_library_exists(dld shl_load "" HAVE_SHLLOAD)
+        if(HAVE_SHLLOAD)
+            target_link_libraries(LibXml2 PRIVATE dld)
+            set(MODULE_LIBS "-ldld")
+        endif()
+    endif()
+endif()
+
+if(UNIX)
+    target_link_libraries(LibXml2 PRIVATE m)
+    set(LIBM "-lm")
+endif()
+
+if(WIN32)
+    target_link_libraries(LibXml2 PRIVATE bcrypt)
+    set(CRYPTO_LIBS "-lbcrypt")
+endif()
+
+if(LIBXML2_WITH_ICONV)
+    target_link_libraries(LibXml2 PRIVATE Iconv::Iconv)
+    if(NOT Iconv_IS_BUILT_IN)
+        set(ICONV_LIBS "-liconv")
+    endif()
+endif()
+
+if(LIBXML2_WITH_ICU)
+    target_link_libraries(LibXml2 PRIVATE ICU::uc)
+    set(ICU_LDFLAGS "-licuuc")
+    list(APPEND XML_PRIVATE_LIBS "${ICU_LDFLAGS}")
+    pkg_check_modules(ICU_PC IMPORTED_TARGET icu-uc)
+    if(ICU_PC_FOUND)
+        list(APPEND XML_PC_REQUIRES icu-uc)
+    else()
+        list(APPEND XML_PC_LIBS "${ICU_LDFLAGS}")
+    endif()
+endif()
+
+if(LIBXML2_WITH_THREADS)
+    target_link_libraries(LibXml2 PRIVATE Threads::Threads)
+endif()
+
+if(LIBXML2_WITH_ZLIB)
+    target_link_libraries(LibXml2 PRIVATE ZLIB::ZLIB)
+    set(ZLIB_LDFLAGS "-lz")
+    list(APPEND XML_PRIVATE_LIBS "${ZLIB_LDFLAGS}")
+    pkg_check_modules(ZLIB_PC IMPORTED_TARGET zlib)
+    if(ZLIB_PC_FOUND)
+        list(APPEND XML_PC_REQUIRES zlib)
+    else()
+        list(APPEND XML_PC_LIBS "${ZLIB_LDFLAGS}")
+    endif()
+endif()
+
+if(CMAKE_C_COMPILER_ID MATCHES "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    # These compiler flags can break the checks above so keep them here.
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pedantic -Wall -Wextra -Wshadow \
+-Wpointer-arith -Wcast-align -Wwrite-strings \
+-Wstrict-prototypes -Wmissing-prototypes \
+-Wno-long-long -Wno-format-extra-args -Wno-array-bounds")
+endif()
+
+set(LIBXML_MINOR_COMPAT 14)
+math(EXPR LIBXML_SOVERSION "${LIBXML_MAJOR_VERSION} + ${LIBXML_MINOR_COMPAT}")
+math(EXPR LIBXML_AGE "${LIBXML_MINOR_VERSION} - ${LIBXML_MINOR_COMPAT}")
+math(EXPR LIBXML_MACHO_COMPAT "${LIBXML_MAJOR_VERSION} + ${LIBXML_MINOR_VERSION} + 1")
+set_target_properties(
+    LibXml2
+    PROPERTIES
+    IMPORT_PREFIX lib
+    OUTPUT_NAME xml2
+    POSITION_INDEPENDENT_CODE ON
+    PREFIX lib
+    VERSION "${LIBXML_SOVERSION}.${LIBXML_AGE}.${LIBXML_MICRO_VERSION}"
+    SOVERSION ${LIBXML_SOVERSION}
+    MACHO_COMPATIBILITY_VERSION ${LIBXML_MACHO_COMPAT}
+    MACHO_CURRENT_VERSION "${LIBXML_MACHO_COMPAT}.${LIBXML_MICRO_VERSION}"
+)
+
+if(MSVC)
+    if(BUILD_SHARED_LIBS)
+        set_target_properties(
+            LibXml2
+            PROPERTIES
+            DEBUG_POSTFIX d
+        )
+    else()
+        set_target_properties(
+            LibXml2
+            PROPERTIES
+            DEBUG_POSTFIX sd
+            MINSIZEREL_POSTFIX s
+            RELEASE_POSTFIX s
+            RELWITHDEBINFO_POSTFIX s
+        )
+    endif()
+endif()
+
+set(XML_SYSCONFDIR "${CMAKE_INSTALL_FULL_SYSCONFDIR}")
+
+install(FILES ${LIBXML2_HDRS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/libxml2/libxml COMPONENT development)
+
+install(
+    TARGETS    LibXml2
+    EXPORT LibXml2
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT development
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT runtime NAMELINK_COMPONENT development
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT runtime
+)
+
+if(MSVC AND BUILD_SHARED_LIBS)
+    install(FILES $<TARGET_PDB_FILE:LibXml2> DESTINATION ${CMAKE_INSTALL_BINDIR} CONFIGURATIONS Debug RelWithDebInfo COMPONENT debug)
+endif()
+
+if(LIBXML2_WITH_PROGRAMS)
+    add_executable(xmllint xmllint.c shell.c lintmain.c)
+    set(PROGRAMS xmllint)
+    if(LIBXML2_WITH_CATALOG AND LIBXML2_WITH_OUTPUT)
+        add_executable(xmlcatalog xmlcatalog.c)
+        list(APPEND PROGRAMS xmlcatalog)
+    endif()
+    foreach(PROGRAM ${PROGRAMS})
+        add_executable(LibXml2::${PROGRAM} ALIAS ${PROGRAM})
+        target_link_libraries(${PROGRAM} LibXml2)
+        if(HAVE_LIBHISTORY)
+            target_link_libraries(${PROGRAM} history)
+        endif()
+        if(HAVE_LIBREADLINE)
+            target_link_libraries(${PROGRAM} readline)
+        endif()
+        install(TARGETS    ${PROGRAM} EXPORT LibXml2 RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT programs)
+    endforeach()
+endif()
+
+if(LIBXML2_WITH_TESTS)
+    enable_testing()
+    set(
+        TESTS
+        runtest
+        runxmlconf
+        runsuite
+        testapi
+        testchar
+        testdict
+        testModule
+        testlimits
+        testparser
+        testrecurse
+    )
+    foreach(TEST ${TESTS})
+        add_executable(${TEST} ${TEST}.c)
+        target_link_libraries(${TEST} LibXml2)
+    endforeach()
+    if(Threads_FOUND)
+        foreach(TEST runtest)
+            target_link_libraries(${TEST} Threads::Threads)
+        endforeach()
+    endif()
+    add_test(NAME runtest COMMAND runtest --out ${CMAKE_CURRENT_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    add_test(NAME runsuite COMMAND runsuite WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/xmlconf/xmlconf.xml)
+        add_test(NAME runxmlconf COMMAND runxmlconf WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    endif()
+    add_test(NAME testapi COMMAND testapi)
+    add_test(NAME testchar COMMAND testchar)
+    add_test(NAME testdict COMMAND testdict)
+    add_test(NAME testparser COMMAND testparser WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+    add_test(NAME testrecurse COMMAND testrecurse WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
+
+if(LIBXML2_WITH_DOCS OR LIBXML2_WITH_PYTHON)
+    set(DOXYFILE ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile)
+    add_custom_command(
+        OUTPUT doc/html doc/xml
+        COMMAND ${CMAKE_COMMAND} -E env
+            SOURCE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}/
+            BUILD_ROOT=${CMAKE_CURRENT_BINARY_DIR}/
+            doxygen -q ${DOXYFILE}
+        MAIN_DEPENDENCY ${DOXYFILE}
+        DEPENDS ${LIBXML2_HDRS} ${LIBXML2_SRCS}
+    )
+    add_custom_target(Doxygen ALL DEPENDS doc/html doc/xml)
+endif()
+
+if(LIBXML2_WITH_PYTHON)
+    add_custom_command(
+        OUTPUT
+            libxml2-py.c
+            libxml2-py.h
+            libxml2.py
+        COMMAND
+            ${Python3_EXECUTABLE}
+            ${CMAKE_CURRENT_SOURCE_DIR}/python/generator.py
+            ${CMAKE_CURRENT_BINARY_DIR}
+        DEPENDS
+            python/generator.py
+            Doxygen
+    )
+
+    Python3_add_library(
+        LibXml2Mod MODULE WITH_SOABI
+        libxml2-py.c
+        libxml2-py.h
+        python/libxml.c
+        python/libxml_wrap.h
+        python/types.c
+    )
+    target_include_directories(
+        LibXml2Mod
+        PRIVATE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/python>
+    )
+    target_link_libraries(LibXml2Mod PRIVATE LibXml2)
+    set_target_properties(
+        LibXml2Mod
+        PROPERTIES
+        IMPORT_PREFIX lib
+        OUTPUT_NAME xml2mod
+        PREFIX lib
+    )
+    install(
+        TARGETS    LibXml2Mod
+        ARCHIVE DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} COMPONENT development
+        LIBRARY DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} COMPONENT runtime NAMELINK_COMPONENT development
+        RUNTIME DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} COMPONENT runtime
+    )
+    if(MSVC AND BUILD_SHARED_LIBS)
+        install(FILES $<TARGET_PDB_FILE:LibXml2Mod> DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} CONFIGURATIONS Debug RelWithDebInfo COMPONENT debug)
+    endif()
+    install(FILES python/drv_libxml2.py DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} COMPONENT runtime)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libxml2.py DESTINATION ${LIBXML2_PYTHON_INSTALL_DIR} COMPONENT runtime)
+endif()
+
+if (LIBXML2_WITH_DOCS)
+    set(MAN_PAGES doc/xml2-config.1)
+
+    if(LIBXML2_WITH_PROGRAMS)
+        set(PROGNAMES xmllint)
+        if(LIBXML2_WITH_CATALOG AND LIBXML2_WITH_OUTPUT)
+            list(APPEND PROGNAMES xmlcatalog)
+        endif()
+        foreach(PROG IN ITEMS ${PROGNAMES})
+            set(XML_SRC ${CMAKE_CURRENT_SOURCE_DIR}/doc/${PROG}.xml)
+
+            add_custom_command(
+                OUTPUT ${PROG}.1
+                COMMAND xsltproc
+                    --nonet --novalid
+                    --param man.output.quietly 1
+                    -o ${PROG}.1
+                    http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl
+                    ${XML_SRC}
+                MAIN_DEPENDENCY ${XML_SRC}
+            )
+            list(APPEND MAN_PAGES ${CMAKE_CURRENT_BINARY_DIR}/${PROG}.1)
+
+            add_custom_command(
+                OUTPUT ${PROG}.html
+                COMMAND xsltproc
+                    --nonet --novalid
+                    -o ${PROG}.html
+                    http://docbook.sourceforge.net/release/xsl/current/html/docbook.xsl
+                    ${XML_SRC}
+                MAIN_DEPENDENCY ${XML_SRC}
+            )
+            list(APPEND HTML_PAGES ${CMAKE_CURRENT_BINARY_DIR}/${PROG}.html)
+        endforeach()
+
+        add_custom_target(DocBook ALL DEPENDS ${MAN_PAGES} ${HTML_PAGES})
+
+        install(
+            FILES ${HTML_PAGES}
+            DESTINATION ${CMAKE_INSTALL_DOCDIR}
+            COMPONENT documentation
+        )
+    endif()
+
+    install(
+        FILES ${MAN_PAGES}
+        DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
+        COMPONENT documentation
+    )
+    install(
+        DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/doc/html
+        DESTINATION ${CMAKE_INSTALL_DOCDIR}
+        COMPONENT documentation
+    )
+endif()
+
+configure_package_config_file(
+    libxml2-config.cmake.cmake.in libxml2-config.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libxml2
+)
+
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/libxml2-config.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libxml2
+    COMPONENT development
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/libxml2-config-version.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion
+)
+
+install(
+    FILES ${CMAKE_CURRENT_BINARY_DIR}/libxml2-config-version.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libxml2
+    COMPONENT development
+)
+
+install(
+    EXPORT LibXml2
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/libxml2
+    NAMESPACE LibXml2::
+    FILE libxml2-export.cmake
+    COMPONENT development
+)
+
+configure_file(config.h.cmake.in config.h)
+configure_file(include/libxml/xmlversion.h.in libxml/xmlversion.h)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libxml/xmlversion.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/libxml2/libxml COMPONENT development)
+
+if(LIBXML2_WITH_PYTHON)
+    set(prefix "${CMAKE_INSTALL_PREFIX}")
+    configure_file(python/setup.py.in setup.py @ONLY)
+endif()
+
+set(NON_PC_LIBS "${THREAD_LIBS} ${ICONV_LIBS} ${LIBM} ${WINSOCK_LIBS} ${CRYPTO_LIBS} ${MODULE_LIBS}")
+list(APPEND XML_PC_LIBS "${NON_PC_LIBS}")
+list(APPEND XML_PRIVATE_LIBS "${NON_PC_LIBS}")
+list(REMOVE_DUPLICATES XML_PC_LIBS)
+list(REMOVE_DUPLICATES XML_PRIVATE_LIBS)
+
+list(JOIN XML_PC_REQUIRES " " XML_PC_REQUIRES)
+list(JOIN XML_PC_LIBS " " XML_PC_LIBS)
+list(JOIN XML_PRIVATE_LIBS " " XML_PRIVATE_LIBS)
+
+set(XML_INCLUDEDIR "-I\${includedir}/libxml2")
+set(XML_LIBDIR "-L\${libdir}")
+set(XML_LIBS "-lxml2")
+
+if(BUILD_SHARED_LIBS)
+    set(XML_PC_PRIVATE ".private")
+    set(XML_PC_LIBS_PRIVATE "
+Libs.private:")
+else()
+    set(XML_PRIVATE_LIBS_NO_SHARED "${XML_PRIVATE_LIBS}")
+endif()
+
+if(WIN32)
+    set(XML_STATIC_CFLAGS "-DLIBXML_STATIC")
+    if (BUILD_SHARED_LIBS)
+        set(XML_PC_CFLAGS_PRIVATE "
+Cflags.private:")
+    else()
+        target_compile_definitions(LibXml2 PUBLIC LIBXML_STATIC)
+        set(XML_CFLAGS "${XML_STATIC_CFLAGS}")
+    endif()
+endif()
+
+file(RELATIVE_PATH PACKAGE_RELATIVE_PATH "${CMAKE_INSTALL_FULL_LIBDIR}/pkgconfig" "${CMAKE_INSTALL_PREFIX}")
+string(REGEX REPLACE "/$" "" PACKAGE_RELATIVE_PATH "${PACKAGE_RELATIVE_PATH}")
+
+if(WIN32)
+    set(prefix "\${pcfiledir}/${PACKAGE_RELATIVE_PATH}")
+else()
+    set(prefix "${CMAKE_INSTALL_PREFIX}")
+endif()
+set(exec_prefix "\${prefix}")
+set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+configure_file(libxml-2.0.pc.in libxml-2.0.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libxml-2.0.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT development)
+
+if(WIN32)
+    set(prefix "\$(cd \"\$(dirname \"\$0\")\"; pwd -P)/..")
+endif()
+configure_file(xml2-config.in xml2-config @ONLY)
+install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/xml2-config DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT development)
+
+set(XML_INCLUDEDIR "-I${CMAKE_INSTALL_FULL_INCLUDEDIR}/libxml2")
+set(XML_LIBDIR "-L${CMAKE_INSTALL_FULL_LIBDIR}")
+
+set(CPACK_COMPONENT_DEVELOPMENT_DEPENDS runtime)
+set(CPACK_COMPONENT_PROGRAMS_DEPENDS runtime)
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_DEVELOPMENT_PACKAGE_DEPENDS "${PACKAGE_TARNAME}")
+set(CPACK_DEBIAN_DEVELOPMENT_PACKAGE_NAME "${PACKAGE_TARNAME}-dev")
+set(CPACK_DEBIAN_DEVELOPMENT_PACKAGE_SECTION "libdevel")
+set(CPACK_DEBIAN_PACKAGE_HOMEPAGE ${PACKAGE_URL})
+set(CPACK_DEBIAN_PACKAGE_NAME ${PACKAGE_TARNAME})
+set(CPACK_DEBIAN_PACKAGE_SECTION "devel")
+set(CPACK_DEBIAN_PROGRAMS_PACKAGE_DEPENDS "${PACKAGE_TARNAME}")
+set(CPACK_DEBIAN_PROGRAMS_PACKAGE_NAME "${PACKAGE_TARNAME}-utils")
+set(CPACK_DEBIAN_PROGRAMS_PACKAGE_SECTION "utils")
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME ${PACKAGE_TARNAME})
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_RECOMMENDS "${PACKAGE_TARNAME}-utils")
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_SECTION "libs")
+set(CPACK_NSIS_PACKAGE_NAME ${PACKAGE_STRING})
+set(CPACK_NSIS_URL_INFO_ABOUT ${PACKAGE_URL})
+set(CPACK_PACKAGE_DISPLAY_NAME ${PACKAGE_STRING})
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PACKAGE_TARNAME}-${PACKAGE_VERSION}")
+set(CPACK_PACKAGE_NAME ${PACKAGE_TARNAME})
+set(CPACK_PACKAGE_VERSION ${PACKAGE_VERSION})
+set(CPACK_PACKAGE_VERSION_MAJOR ${LIBXML_MAJOR_VERSION})
+set(CPACK_PACKAGE_VERSION_MINOR ${LIBXML_MINOR_VERSION})
+set(CPACK_PACKAGE_VERSION_PATCH ${LIBXML_MICRO_VERSION})
+set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_CURRENT_SOURCE_DIR}/Copyright)
+set(CPACK_RPM_COMPONENT_INSTALL ON)
+set(CPACK_RPM_development_PACKAGE_NAME "${PACKAGE_NAME}-devel")
+set(CPACK_RPM_development_PACKAGE_REQUIRES "${PACKAGE_NAME}")
+set(CPACK_RPM_PACKAGE_GROUP "Development/Libraries")
+set(CPACK_RPM_PACKAGE_NAME ${PACKAGE_TARNAME})
+set(CPACK_RPM_PACKAGE_URL ${PACKAGE_URL})
+set(CPACK_RPM_programs_PACKAGE_NAME "${PACKAGE_NAME}-utils")
+set(CPACK_RPM_programs_PACKAGE_REQUIRES "${PACKAGE_NAME}")
+set(CPACK_RPM_runtime_PACKAGE_NAME "${PACKAGE_NAME}")
+set(CPACK_RPM_runtime_PACKAGE_SUGGESTS "${PACKAGE_NAME}-utils")
+
+include(CPack)

Copyright

@@ -0,0 +1,24 @@
+Except where otherwise noted in the source code (e.g. the files dict.c and
+list.c, which are covered by a similar licence but with different Copyright
+notices) all the files are:
+
+ Copyright (C) 1998-2012 Daniel Veillard.  All Rights Reserved.
+ Copyright (C) The Libxml2 Contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is fur-
+nished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FIT-
+NESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

HTMLtree.c

@@ -0,0 +1,1314 @@
+/*
+ * HTMLtree.c : implementation of access function for an HTML tree.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_HTML_ENABLED
+
+#include <string.h> /* for memset() only ! */
+#include <ctype.h>
+#include <stdlib.h>
+
+#include <libxml/xmlmemory.h>
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/parserInternals.h>
+#include <libxml/uri.h>
+
+#include "private/buf.h"
+#include "private/html.h"
+#include "private/error.h"
+#include "private/html.h"
+#include "private/io.h"
+#include "private/save.h"
+#include "private/tree.h"
+
+/************************************************************************
+ *									*
+ *		Getting/Setting encoding meta tags			*
+ *									*
+ ************************************************************************/
+
+typedef struct {
+    xmlAttrPtr attr; /* charset or content */
+    const xmlChar *attrValue;
+    htmlMetaEncodingOffsets off;
+} htmlMetaEncoding;
+
+static htmlNodePtr
+htmlFindFirstChild(htmlNodePtr parent, const char *name) {
+    htmlNodePtr child;
+
+    for (child = parent->children; child != NULL; child = child->next) {
+        if ((child->type == XML_ELEMENT_NODE) &&
+            (xmlStrcasecmp(child->name, BAD_CAST name) == 0))
+            return(child);
+    }
+
+    return(NULL);
+}
+
+static htmlNodePtr
+htmlFindHead(htmlDocPtr doc) {
+    htmlNodePtr html;
+
+    if (doc == NULL)
+        return(NULL);
+
+    html = htmlFindFirstChild((htmlNodePtr) doc, "html");
+    if (html == NULL)
+        return(NULL);
+
+    return(htmlFindFirstChild(html, "head"));
+}
+
+int
+htmlParseContentType(const xmlChar *val, htmlMetaEncodingOffsets *off) {
+    const xmlChar *p = val;
+
+    while (1) {
+        size_t start, end;
+
+        while ((*p != 'c') && (*p != 'C')) {
+            if (*p == 0)
+                return(0);
+            p += 1;
+        }
+        p += 1;
+
+        if (xmlStrncasecmp(p, BAD_CAST "harset", 6) != 0)
+            continue;
+
+        p += 6;
+        while (IS_WS_HTML(*p)) p += 1;
+
+        if (*p != '=')
+            continue;
+
+        p += 1;
+        while (IS_WS_HTML(*p)) p += 1;
+
+        if (*p == 0)
+            return(0);
+
+        if ((*p == '"') || (*p == '\'')) {
+            int quote = *p;
+
+            p += 1;
+            while (IS_WS_HTML(*p)) p += 1;
+
+            start = p - val;
+            end = start;
+
+            while (*p != quote) {
+                if (*p == 0)
+                    return(0);
+                if (!IS_WS_HTML(*p))
+                    end = p + 1 - val;
+                p += 1;
+            }
+        } else {
+            start = p - val;
+
+            while ((*p != 0) && (*p != ';') && (!IS_WS_HTML(*p)))
+                p += 1;
+
+            end = p - val;
+        }
+
+        off->start = start;
+        off->end = end;
+        off->size = p - val + strlen((char *) p);
+
+        return(1);
+    }
+
+    return(0);
+}
+
+static xmlAttrPtr
+htmlFindMetaEncodingAttr(htmlNodePtr elem, int *outIsContentType) {
+    xmlAttrPtr attr, contentAttr = NULL;
+    int isContentType = 0;
+
+    if (xmlStrcasecmp(elem->name, BAD_CAST "meta") != 0)
+        return(NULL);
+
+    for (attr = elem->properties; attr != NULL; attr = attr->next) {
+        if (attr->ns != NULL)
+            continue;
+        if (xmlStrcasecmp(attr->name, BAD_CAST "charset") == 0) {
+            *outIsContentType = 0;
+            return(attr);
+        }
+        if (xmlStrcasecmp(attr->name, BAD_CAST "content") == 0)
+            contentAttr = attr;
+        if ((xmlStrcasecmp(attr->name, BAD_CAST "http-equiv") == 0) &&
+            (attr->children != NULL) &&
+            (attr->children->type == XML_TEXT_NODE) &&
+            (attr->children->next == NULL) &&
+            (xmlStrcasecmp(attr->children->content,
+                           BAD_CAST "Content-Type") == 0))
+            isContentType = 1;
+    }
+
+    if ((isContentType) && (contentAttr != NULL)) {
+        *outIsContentType = 1;
+        return(contentAttr);
+    }
+
+    return(NULL);
+}
+
+static int
+htmlParseMetaEncoding(htmlNodePtr elem, htmlMetaEncoding *menc) {
+    xmlAttrPtr attr;
+    const xmlChar *val = NULL;
+    int isContentType;
+
+    if ((elem->type != XML_ELEMENT_NODE) ||
+        (xmlStrcasecmp(elem->name, BAD_CAST "meta") != 0))
+        return(0);
+
+    attr = htmlFindMetaEncodingAttr(elem, &isContentType);
+    if (attr == NULL)
+        return(0);
+
+    if ((attr->children != NULL) &&
+        (attr->children->type == XML_TEXT_NODE) &&
+        (attr->children->next == NULL) &&
+        (attr->children->content != NULL))
+        val = attr->children->content;
+    else
+        val = BAD_CAST "";
+
+
+    if (!isContentType) {
+        size_t size = strlen((char *) val);
+        size_t start = 0;
+        size_t end = size;
+
+        while ((start < size) && (IS_WS_HTML(val[start])))
+            start += 1;
+
+        while ((end > 0) && (IS_WS_HTML(val[end-1])))
+            end -= 1;
+
+        menc->attr = attr;
+        menc->attrValue = val;
+        menc->off.start = start;
+        menc->off.end = end;
+        menc->off.size = size;
+
+        return(1);
+    } else {
+        if (htmlParseContentType(val, &menc->off)) {
+            menc->attr = attr;
+            menc->attrValue = val;
+
+            return(1);
+        }
+    }
+
+    return(0);
+}
+
+static xmlChar *
+htmlUpdateMetaEncoding(htmlMetaEncoding *menc, const char *encoding) {
+    xmlChar *newVal, *p;
+    size_t size, oldEncSize, newEncSize;
+
+    /*
+     * The pseudo "HTML" encoding only produces ASCII.
+     */
+    if (xmlStrcasecmp(BAD_CAST encoding, BAD_CAST "HTML") == 0)
+        encoding = "ASCII";
+
+    oldEncSize = menc->off.end - menc->off.start;
+    newEncSize = strlen((char *) encoding);
+    size = menc->off.size - oldEncSize + newEncSize;
+    newVal = xmlMalloc(size + 1);
+    if (newVal == NULL)
+        return(NULL);
+
+    p = newVal;
+    memcpy(p, menc->attrValue, menc->off.start);
+    p += menc->off.start;
+    memcpy(p, encoding, newEncSize);
+    p += newEncSize;
+    memcpy(p, menc->attrValue + menc->off.end, menc->off.size - menc->off.end);
+    newVal[size] = 0;
+
+    return(newVal);
+}
+
+/**
+ * Look up and encoding declaration in the meta tags.
+ *
+ * The returned string points into attribute content and can contain
+ * trailing garbage. It should be copied before modifying or freeing
+ * nodes.
+ *
+ * @param doc  the document
+ * @returns the encoding ot NULL if not found.
+ */
+const xmlChar *
+htmlGetMetaEncoding(xmlDoc *doc) {
+    htmlNodePtr head, node;
+
+    head = htmlFindHead(doc);
+    if (head == NULL)
+        return(NULL);
+
+    for (node = head->children; node != NULL; node = node->next) {
+        htmlMetaEncoding menc;
+
+        if (htmlParseMetaEncoding(node, &menc)) {
+            /*
+             * Returning a `const xmlChar *` only allows to return
+             * a suffix. In http-equiv meta tags, there could be
+             * more data after the charset, although it's probably
+             * rare in practice.
+             */
+            return(menc.attrValue + menc.off.start);
+        }
+    }
+
+    return(NULL);
+}
+
+/**
+ * Creates or updates a meta tag with an encoding declaration.
+ *
+ * NOTE: This will not change the document content encoding.
+ *
+ * @param doc  the document
+ * @param encoding  the encoding string
+ * @returns 0 in case of success, 1 if no head element was found or
+ * arguments are invalid and -1 if memory allocation failed.
+ */
+int
+htmlSetMetaEncoding(xmlDoc *doc, const xmlChar *encoding) {
+    htmlNodePtr head, meta;
+    int found = 0;
+
+    if (encoding == NULL)
+        return(1);
+
+    head = htmlFindHead(doc);
+    if (head == NULL)
+        return(1);
+
+    for (meta = head->children; meta != NULL; meta = meta->next) {
+        htmlMetaEncoding menc;
+
+        if (htmlParseMetaEncoding(meta, &menc)) {
+            xmlChar *newVal;
+            int ret;
+
+            found = 1;
+
+            newVal = htmlUpdateMetaEncoding(&menc, (char *) encoding);
+            if (newVal == NULL)
+                return(-1);
+            xmlNodeSetContent((xmlNodePtr) menc.attr, NULL);
+            ret = xmlNodeAddContent((xmlNodePtr) menc.attr, newVal);
+            xmlFree(newVal);
+
+            if (ret < 0)
+                return(-1);
+        }
+    }
+
+    if (found)
+        return(0);
+
+    meta = xmlNewDocNode(head->doc, NULL, BAD_CAST "meta", NULL);
+    if (meta == NULL)
+        return(-1);
+
+    if (xmlNewProp(meta, BAD_CAST "charset", encoding) == NULL) {
+        xmlFreeNode(meta);
+        return(-1);
+    }
+
+    if (head->children == NULL)
+        xmlAddChild(head, meta);
+    else
+        xmlAddPrevSibling(head->children, meta);
+
+    return(0);
+}
+
+/**
+ * Determine if a given attribute is a boolean attribute. This
+ * doesn't handle HTML5.
+ *
+ * @deprecated Internal function, don't use.
+ *
+ * @param name  the name of the attribute to check
+ * @returns false if the attribute is not boolean, true otherwise.
+ */
+int
+htmlIsBooleanAttr(const xmlChar *name)
+{
+    const char *str = NULL;
+
+    if (name == NULL)
+        return(0);
+
+    /*
+     * These are the HTML attributes which will be output
+     * in minimized form, i.e. `<option selected="selected">` will be
+     * output as `<option selected>`, as per XSLT 1.0 16.2 "HTML Output
+     * Method":
+     *
+     * "checked", "compact", "declare", "defer", "disabled", "ismap",
+     * "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
+     * "selected"
+     *
+     * Additional attributes from HTML5 (not implemented yet):
+     *
+     * "allowfullscreen", "alpha", "async", "autofocus", "autoplay",
+     * "controls", "default", "formnovalidate", "inert", "itemscope",
+     * "loop", "muted", "nomodule", "novalidate", "open", "playsinline",
+     * "required", "reversed", "shadowrootdelegatesfocus",
+     * "shadowrootclonable", "shadowrootserializable",
+     * "shadowrootcustomelementregistry", "truespeed"
+     */
+
+    switch (name[0] | 0x20) {
+        case 'c':
+            name += 1;
+            switch (name[0] | 0x20) {
+                case 'h': str = "ecked"; break;
+                case 'o': str = "mpact"; break;
+            }
+            break;
+        case 'd':
+            name += 1;
+            switch (name[0] | 0x20) {
+                case 'e':
+                    name += 1;
+                    switch (name[0] | 0x20) {
+                        case 'c': str = "lare"; break;
+                        case 'f': str = "er"; break;
+                    }
+                    break;
+                case 'i': str = "sabled"; break;
+            }
+            break;
+        case 'i':
+            str = "smap";
+            break;
+        case 'm':
+            str = "ultiple";
+            break;
+        case 'n':
+            name += 1;
+            if ((name[0] | 0x20) != 'o')
+                break;
+            name += 1;
+            switch (name[0] | 0x20) {
+                case 'h': str = "ref"; break;
+                case 'r': str = "esize"; break;
+                case 's': str = "hade"; break;
+                case 'w': str = "rap"; break;
+            }
+            break;
+        case 'r':
+            str = "eadonly";
+            break;
+        case 's':
+            str = "elected";
+            break;
+    }
+
+    if (str == NULL)
+        return(0);
+
+    return(xmlStrcasecmp(name + 1, BAD_CAST str) == 0);
+}
+
+#ifdef LIBXML_OUTPUT_ENABLED
+/************************************************************************
+ *									*
+ *		Dumping HTML tree content to a simple buffer		*
+ *									*
+ ************************************************************************/
+
+static xmlParserErrors
+htmlFindOutputEncoder(const char *encoding, xmlCharEncodingHandler **out) {
+    /*
+     * Fallback to HTML if the encoding is unspecified
+     */
+    if (encoding == NULL)
+        encoding = "HTML";
+
+    return(xmlOpenCharEncodingHandler(encoding, /* output */ 1, out));
+}
+
+/**
+ * Serialize an HTML document to an xmlBuf.
+ *
+ * @param buf  the xmlBuf output
+ * @param doc  the document (unused)
+ * @param cur  the current node
+ * @param format  should formatting newlines been added
+ * @returns the number of bytes written or -1 in case of error
+ */
+static size_t
+htmlBufNodeDumpFormat(xmlBufPtr buf, xmlDocPtr doc ATTRIBUTE_UNUSED,
+                      xmlNodePtr cur, int format) {
+    size_t use;
+    size_t ret;
+    xmlOutputBufferPtr outbuf;
+
+    if (cur == NULL) {
+	return ((size_t) -1);
+    }
+    if (buf == NULL) {
+	return ((size_t) -1);
+    }
+    outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
+    if (outbuf == NULL)
+	return ((size_t) -1);
+    memset(outbuf, 0, sizeof(xmlOutputBuffer));
+    outbuf->buffer = buf;
+    outbuf->encoder = NULL;
+    outbuf->writecallback = NULL;
+    outbuf->closecallback = NULL;
+    outbuf->context = NULL;
+    outbuf->written = 0;
+
+    use = xmlBufUse(buf);
+    htmlNodeDumpInternal(outbuf, cur, NULL, format);
+    if (outbuf->error)
+        ret = (size_t) -1;
+    else
+        ret = xmlBufUse(buf) - use;
+    xmlFree(outbuf);
+    return (ret);
+}
+
+/**
+ * Serialize an HTML node to an xmlBuffer. Always uses UTF-8.
+ *
+ * @param buf  the HTML buffer output
+ * @param doc  the document
+ * @param cur  the current node
+ * @returns the number of bytes written or -1 in case of error
+ */
+int
+htmlNodeDump(xmlBuffer *buf, xmlDoc *doc, xmlNode *cur) {
+    xmlBufPtr buffer;
+    size_t ret1;
+    int ret2;
+
+    if ((buf == NULL) || (cur == NULL))
+        return(-1);
+
+    xmlInitParser();
+    buffer = xmlBufFromBuffer(buf);
+    if (buffer == NULL)
+        return(-1);
+
+    ret1 = htmlBufNodeDumpFormat(buffer, doc, cur, 1);
+
+    ret2 = xmlBufBackToBuffer(buffer, buf);
+
+    if ((ret1 == (size_t) -1) || (ret2 < 0))
+        return(-1);
+    return(ret1 > INT_MAX ? INT_MAX : ret1);
+}
+
+/**
+ * Serialize an HTML node to an xmlBuffer.
+ *
+ * If encoding is NULL, ASCII with HTML 4.0 named character entities
+ * will be used. This is inefficient compared to UTF-8 and might be
+ * changed in a future version.
+ *
+ * @param out  the FILE pointer
+ * @param doc  the document (unused)
+ * @param cur  the current node
+ * @param encoding  the document encoding (optional)
+ * @param format  should formatting newlines been added
+ * @returns the number of bytes written or -1 in case of failure.
+ */
+int
+htmlNodeDumpFileFormat(FILE *out, xmlDoc *doc ATTRIBUTE_UNUSED,
+	               xmlNode *cur, const char *encoding, int format) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler;
+    int ret;
+
+    xmlInitParser();
+
+    /*
+     * save the content to a temp buffer.
+     */
+    if (htmlFindOutputEncoder(encoding, &handler) != XML_ERR_OK)
+        return(-1);
+    buf = xmlOutputBufferCreateFile(out, handler);
+    if (buf == NULL) {
+        xmlCharEncCloseFunc(handler);
+        return(-1);
+    }
+
+    htmlNodeDumpInternal(buf, cur, NULL, format);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * Same as #htmlNodeDumpFileFormat with `format` set to 1 which is
+ * typically undesired. Use of this function is DISCOURAGED in favor
+ * of #htmlNodeDumpFileFormat.
+ *
+ * @param out  the FILE pointer
+ * @param doc  the document
+ * @param cur  the current node
+ */
+void
+htmlNodeDumpFile(FILE *out, xmlDoc *doc, xmlNode *cur) {
+    htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);
+}
+
+/**
+ * Serialize an HTML node to a memory, also returning the size of
+ * the result. It's up to the caller to free the memory.
+ *
+ * Uses the encoding of the document. If the document has no
+ * encoding, ASCII with HTML 4.0 named character entities will
+ * be used. This is inefficient compared to UTF-8 and might be
+ * changed in a future version.
+ *
+ * @param cur  the document
+ * @param mem  OUT: the memory pointer
+ * @param size  OUT: the memory length
+ * @param format  should formatting newlines been added
+ */
+void
+htmlDocDumpMemoryFormat(xmlDoc *cur, xmlChar**mem, int *size, int format) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+
+    xmlInitParser();
+
+    if ((mem == NULL) || (size == NULL))
+        return;
+    *mem = NULL;
+    *size = 0;
+    if (cur == NULL)
+	return;
+
+    if (htmlFindOutputEncoder((char *) cur->encoding, &handler) != XML_ERR_OK)
+        return;
+    buf = xmlAllocOutputBuffer(handler);
+    if (buf == NULL) {
+        xmlCharEncCloseFunc(handler);
+	return;
+    }
+
+    htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
+
+    xmlOutputBufferFlush(buf);
+
+    if (!buf->error) {
+        if (buf->conv != NULL) {
+            *size = xmlBufUse(buf->conv);
+            *mem = xmlStrndup(xmlBufContent(buf->conv), *size);
+        } else {
+            *size = xmlBufUse(buf->buffer);
+            *mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
+        }
+    }
+
+    xmlOutputBufferClose(buf);
+}
+
+/**
+ * Same as #htmlDocDumpMemoryFormat with `format` set to 1 which
+ * is typically undesired. Also see the warnings there. Use of
+ * this function is DISCOURAGED in favor of
+ * #htmlDocContentDumpFormatOutput.
+ *
+ * @param cur  the document
+ * @param mem  OUT: the memory pointer
+ * @param size  OUT: the memory length
+ */
+void
+htmlDocDumpMemory(xmlDoc *cur, xmlChar**mem, int *size) {
+    htmlDocDumpMemoryFormat(cur, mem, size, 1);
+}
+
+
+/************************************************************************
+ *									*
+ *		Dumping HTML tree content to an I/O output buffer	*
+ *									*
+ ************************************************************************/
+
+/**
+ * Serialize the HTML document's DTD, if any.
+ *
+ * Ignores `encoding` and uses the encoding of the output buffer.
+ *
+ * @param buf  the HTML buffer output
+ * @param doc  the document
+ * @param encoding  the encoding string (unused)
+ */
+static void
+htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
+	          const char *encoding ATTRIBUTE_UNUSED) {
+    xmlDtdPtr cur = doc->intSubset;
+
+    if (cur == NULL)
+	return;
+    xmlOutputBufferWrite(buf, 10, "<!DOCTYPE ");
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+    if (cur->ExternalID != NULL) {
+	xmlOutputBufferWrite(buf, 8, " PUBLIC ");
+	xmlOutputBufferWriteQuotedString(buf, cur->ExternalID);
+	if (cur->SystemID != NULL) {
+	    xmlOutputBufferWrite(buf, 1, " ");
+	    xmlOutputBufferWriteQuotedString(buf, cur->SystemID);
+	}
+    } else if (cur->SystemID != NULL &&
+	       xmlStrcmp(cur->SystemID, BAD_CAST "about:legacy-compat")) {
+	xmlOutputBufferWrite(buf, 8, " SYSTEM ");
+	xmlOutputBufferWriteQuotedString(buf, cur->SystemID);
+    }
+    xmlOutputBufferWrite(buf, 2, ">\n");
+}
+
+static void
+htmlSerializeUri(xmlOutputBufferPtr buf, const xmlChar *content) {
+    const xmlChar *tmp = content;
+
+    /*
+     * See appendix "B.2.1 Non-ASCII characters in URI attribute
+     * values" in the HTML 4.01 spec. This is also recommended
+     * by the HTML output method of the XSLT 1.0 spec.
+     *
+     * We also escape space and control chars.
+     */
+
+    /* Skip over initial whitespace */
+    while (IS_WS_HTML(*tmp)) tmp++;
+    if (tmp > content) {
+        xmlOutputBufferWrite(buf, tmp - content, (char *) content);
+        content = tmp;
+    }
+
+    while (1) {
+        char escbuf[3];
+        const char *repl;
+        int replSize;
+        int c = *tmp;
+
+        while ((c > 0x20) && (c < 0x7F) && (c != '"') && (c != '&')) {
+            tmp += 1;
+            c = *tmp;
+        }
+
+        if (tmp > content)
+            xmlOutputBufferWrite(buf, tmp - content, (char *) content);
+
+        if ((c <= 0x20) || (c >= 0x7F)) {
+            static const char hex[16] = {
+                '0', '1', '2', '3', '4', '5', '6', '7',
+                '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+            };
+
+            if (c == 0)
+                break;
+
+            escbuf[0] = '%';
+            escbuf[1] = hex[(c >> 4) & 0x0F];
+            escbuf[2] = hex[c & 0x0F];
+            repl = escbuf;
+            replSize = 3;
+        } else if (c == '"') {
+            repl = "&quot;";
+            replSize = 6;
+        } else {
+            repl = "&amp;";
+            replSize = 5;
+        }
+
+        xmlOutputBufferWrite(buf, replSize, repl);
+        tmp += 1;
+        content = tmp;
+    }
+}
+
+/**
+ * Serialize an HTML attribute.
+ *
+ * @param buf  the HTML buffer output
+ * @param cur  the attribute pointer
+ */
+static void
+htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlAttrPtr cur) {
+    xmlOutputBufferWrite(buf, 1, " ");
+
+    if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+        xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+        xmlOutputBufferWrite(buf, 1, ":");
+    }
+    xmlOutputBufferWriteString(buf, (const char *)cur->name);
+
+    /*
+     * The HTML5 spec requires to always serialize empty attribute
+     * values as `=""`. We should probably align with HTML5 at some
+     * point.
+     */
+    if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
+        xmlNodePtr child;
+        int isUri;
+
+        xmlOutputBufferWrite(buf, 2, "=\"");
+
+        /*
+         * Special handling of URIs doesn't conform to HTML5 and
+         * should probably be removed at some point.
+         */
+        isUri = (cur->ns == NULL) && (cur->parent != NULL) &&
+                (cur->parent->ns == NULL) &&
+                ((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
+                 (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
+                 (!xmlStrcasecmp(cur->name, BAD_CAST "src")) ||
+                 ((!xmlStrcasecmp(cur->name, BAD_CAST "name")) &&
+                  (!xmlStrcasecmp(cur->parent->name, BAD_CAST "a"))));
+
+        for (child = cur->children; child != NULL; child = child->next) {
+            if (child->type == XML_TEXT_NODE) {
+                const xmlChar *content = child->content;
+
+                if (content == NULL)
+                    continue;
+
+                if (isUri) {
+                    htmlSerializeUri(buf, content);
+                } else {
+                    xmlSerializeText(buf, content, SIZE_MAX,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                }
+            } else if (child->type == XML_ENTITY_REF_NODE) {
+                /* TODO: We should probably expand entity refs */
+                xmlOutputBufferWrite(buf, 1, "&");
+                xmlOutputBufferWriteString(buf, (char *) child->name);
+                xmlOutputBufferWrite(buf, 1, ";");
+            }
+        }
+
+        xmlOutputBufferWrite(buf, 1, "\"");
+    }
+}
+
+/**
+ * Serialize an HTML node to an output buffer.
+ *
+ * If `encoding` is specified, it is used to create or update meta
+ * tags containing the character encoding.
+ *
+ * @param buf  the HTML buffer output
+ * @param cur  the current node
+ * @param encoding  the encoding string (optional)
+ * @param format  should formatting newlines been added
+ */
+void
+htmlNodeDumpInternal(xmlOutputBuffer *buf, xmlNode *cur,
+                     const char *encoding, int format) {
+    xmlNodePtr root, parent, metaHead = NULL;
+    xmlAttrPtr attr;
+    const htmlElemDesc * info;
+    int isRaw = 0;
+
+    xmlInitParser();
+
+    if ((cur == NULL) || (buf == NULL)) {
+	return;
+    }
+
+    root = cur;
+    parent = cur->parent;
+    while (1) {
+        switch (cur->type) {
+        case XML_HTML_DOCUMENT_NODE:
+        case XML_DOCUMENT_NODE:
+            if (((xmlDocPtr) cur)->intSubset != NULL) {
+                htmlDtdDumpOutput(buf, (xmlDocPtr) cur, NULL);
+            }
+            if (cur->children != NULL) {
+                /* Always validate cur->parent when descending. */
+                if (cur->parent == parent) {
+                    parent = cur;
+                    cur = cur->children;
+                    continue;
+                }
+            } else {
+                xmlOutputBufferWrite(buf, 1, "\n");
+            }
+            break;
+
+        case XML_ELEMENT_NODE: {
+            htmlMetaEncoding menc;
+            int isMeta = 0;
+            int addMeta = 0;
+
+            /*
+             * Some users like lxml are known to pass nodes with a corrupted
+             * tree structure. Fall back to a recursive call to handle this
+             * case.
+             */
+            if ((cur->parent != parent) && (cur->children != NULL)) {
+                htmlNodeDumpInternal(buf, cur, encoding, format);
+                break;
+            }
+
+            /*
+             * Get specific HTML info for that node.
+             */
+            if (cur->ns == NULL)
+                info = htmlTagLookup(cur->name);
+            else
+                info = NULL;
+
+            if (encoding != NULL) {
+                isMeta = htmlParseMetaEncoding(cur, &menc);
+
+                /*
+                 * Don't add meta tag for "HTML" encoding.
+                 */
+                if ((xmlStrcasecmp(BAD_CAST encoding,
+                                   BAD_CAST "HTML") != 0) &&
+                    (xmlStrcasecmp(cur->name, BAD_CAST "head") == 0) &&
+                    (parent != NULL) &&
+                    (xmlStrcasecmp(parent->name, BAD_CAST "html") == 0) &&
+                    (parent->parent != NULL) &&
+                    (parent->parent->parent == NULL) &&
+                    (metaHead == NULL)) {
+                    xmlNodePtr n;
+
+                    metaHead = cur;
+                    addMeta = 1;
+
+                    for (n = cur->children; n != NULL; n = n->next) {
+                        int unused;
+
+                        if (htmlFindMetaEncodingAttr(n, &unused) != NULL) {
+                            metaHead = NULL;
+                            addMeta = 0;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            xmlOutputBufferWrite(buf, 1, "<");
+            if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+                xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+                xmlOutputBufferWrite(buf, 1, ":");
+            }
+            xmlOutputBufferWriteString(buf, (const char *)cur->name);
+            if (cur->nsDef)
+                xmlNsListDumpOutput(buf, cur->nsDef);
+            attr = cur->properties;
+            while (attr != NULL) {
+                if ((!isMeta) || (attr != menc.attr)) {
+                    htmlAttrDumpOutput(buf, attr);
+                } else {
+                    xmlOutputBufferWrite(buf, 1, " ");
+                    xmlOutputBufferWriteString(buf, (char *) attr->name);
+
+                    xmlOutputBufferWrite(buf, 2, "=\"");
+                    xmlSerializeText(buf, menc.attrValue, menc.off.start,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                    xmlSerializeText(buf, menc.attrValue + menc.off.end,
+                                     menc.off.size - menc.off.end,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                    xmlOutputBufferWrite(buf, 1, "\"");
+                }
+                attr = attr->next;
+            }
+
+            if ((info != NULL) && (info->empty)) {
+                xmlOutputBufferWrite(buf, 1, ">");
+            } else if (cur->children == NULL) {
+                if (addMeta) {
+                    xmlOutputBufferWrite(buf, 16, "><meta charset=\"");
+                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                    xmlOutputBufferWrite(buf, 4, "\"></");
+                } else {
+                    xmlOutputBufferWrite(buf, 3, "></");
+                }
+                if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+                    xmlOutputBufferWriteString(buf,
+                            (const char *)cur->ns->prefix);
+                    xmlOutputBufferWrite(buf, 1, ":");
+                }
+                xmlOutputBufferWriteString(buf, (const char *)cur->name);
+                xmlOutputBufferWrite(buf, 1, ">");
+            } else {
+                xmlOutputBufferWrite(buf, 1, ">");
+                if ((format) &&
+                    ((addMeta) ||
+                     ((info != NULL) && (!info->isinline) &&
+                      (cur->children->type != HTML_TEXT_NODE) &&
+                      (cur->children->type != HTML_ENTITY_REF_NODE) &&
+                      (cur->children != cur->last) &&
+                      (cur->name != NULL) &&
+                      (cur->name[0] != 'p')))) /* p, pre, param */
+                    xmlOutputBufferWrite(buf, 1, "\n");
+                if (addMeta) {
+                    xmlOutputBufferWrite(buf, 15, "<meta charset=\"");
+                    xmlSerializeText(buf, BAD_CAST encoding, SIZE_MAX,
+                                     XML_ESCAPE_HTML | XML_ESCAPE_ATTR);
+                    xmlOutputBufferWrite(buf, 2, "\">");
+                    if ((format) &&
+                        (cur->children->type != HTML_TEXT_NODE) &&
+                        (cur->children->type != HTML_ENTITY_REF_NODE))
+                        xmlOutputBufferWrite(buf, 1, "\n");
+                }
+
+                if ((info != NULL) && (info->dataMode >= DATA_RAWTEXT))
+                    isRaw = 1;
+
+                parent = cur;
+                cur = cur->children;
+                continue;
+            }
+
+            if ((format) && (cur->next != NULL) &&
+                (info != NULL) && (!info->isinline)) {
+                if ((cur->next->type != HTML_TEXT_NODE) &&
+                    (cur->next->type != HTML_ENTITY_REF_NODE) &&
+                    (parent != NULL) &&
+                    (parent->name != NULL) &&
+                    (parent->name[0] != 'p')) /* p, pre, param */
+                    xmlOutputBufferWrite(buf, 1, "\n");
+            }
+
+            break;
+        }
+
+        case XML_ATTRIBUTE_NODE:
+            htmlAttrDumpOutput(buf, (xmlAttrPtr) cur);
+            break;
+
+        case HTML_TEXT_NODE:
+            if (cur->content == NULL)
+                break;
+            if ((cur->name == (const xmlChar *)xmlStringTextNoenc) ||
+                (isRaw)) {
+                xmlOutputBufferWriteString(buf, (const char *)cur->content);
+            } else {
+                xmlSerializeText(buf, cur->content, SIZE_MAX, XML_ESCAPE_HTML);
+            }
+            break;
+
+        case HTML_COMMENT_NODE:
+            if (cur->content != NULL) {
+                xmlOutputBufferWrite(buf, 4, "<!--");
+                xmlOutputBufferWriteString(buf, (const char *)cur->content);
+                xmlOutputBufferWrite(buf, 3, "-->");
+            }
+            break;
+
+        case HTML_PI_NODE:
+            if (cur->name != NULL) {
+                xmlOutputBufferWrite(buf, 2, "<?");
+                xmlOutputBufferWriteString(buf, (const char *)cur->name);
+                if (cur->content != NULL) {
+                    xmlOutputBufferWrite(buf, 1, " ");
+                    xmlOutputBufferWriteString(buf,
+                            (const char *)cur->content);
+                }
+                xmlOutputBufferWrite(buf, 1, ">");
+            }
+            break;
+
+        case HTML_ENTITY_REF_NODE:
+            xmlOutputBufferWrite(buf, 1, "&");
+            xmlOutputBufferWriteString(buf, (const char *)cur->name);
+            xmlOutputBufferWrite(buf, 1, ";");
+            break;
+
+        case HTML_PRESERVE_NODE:
+            if (cur->content != NULL) {
+                xmlOutputBufferWriteString(buf, (const char *)cur->content);
+            }
+            break;
+
+        default:
+            break;
+        }
+
+        while (1) {
+            if (cur == root)
+                return;
+            if (cur->next != NULL) {
+                cur = cur->next;
+                break;
+            }
+
+            isRaw = 0;
+
+            cur = parent;
+            /* cur->parent was validated when descending. */
+            parent = cur->parent;
+
+            if ((cur->type == XML_HTML_DOCUMENT_NODE) ||
+                (cur->type == XML_DOCUMENT_NODE)) {
+                xmlOutputBufferWrite(buf, 1, "\n");
+            } else {
+                if ((format) && (cur->ns == NULL))
+                    info = htmlTagLookup(cur->name);
+                else
+                    info = NULL;
+
+                if ((format) && (info != NULL) && (!info->isinline) &&
+                    (cur->last->type != HTML_TEXT_NODE) &&
+                    (cur->last->type != HTML_ENTITY_REF_NODE) &&
+                    ((cur->children != cur->last) || (cur == metaHead)) &&
+                    (cur->name != NULL) &&
+                    (cur->name[0] != 'p')) /* p, pre, param */
+                    xmlOutputBufferWrite(buf, 1, "\n");
+
+                xmlOutputBufferWrite(buf, 2, "</");
+                if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
+                    xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
+                    xmlOutputBufferWrite(buf, 1, ":");
+                }
+                xmlOutputBufferWriteString(buf, (const char *)cur->name);
+                xmlOutputBufferWrite(buf, 1, ">");
+
+                if ((format) && (info != NULL) && (!info->isinline) &&
+                    (cur->next != NULL)) {
+                    if ((cur->next->type != HTML_TEXT_NODE) &&
+                        (cur->next->type != HTML_ENTITY_REF_NODE) &&
+                        (parent != NULL) &&
+                        (parent->name != NULL) &&
+                        (parent->name[0] != 'p')) /* p, pre, param */
+                        xmlOutputBufferWrite(buf, 1, "\n");
+                }
+
+                if (cur == metaHead)
+                    metaHead = NULL;
+            }
+        }
+    }
+}
+
+/**
+ * Serialize an HTML node to an output buffer.
+ *
+ * @param buf  the HTML buffer output
+ * @param doc  the document (unused)
+ * @param cur  the current node
+ * @param encoding  the encoding string (unused)
+ * @param format  should formatting newlines been added
+ */
+void
+htmlNodeDumpFormatOutput(xmlOutputBuffer *buf,
+                         xmlDoc *doc ATTRIBUTE_UNUSED, xmlNode *cur,
+                         const char *encoding ATTRIBUTE_UNUSED, int format) {
+    htmlNodeDumpInternal(buf, cur, NULL, format);
+}
+
+/**
+ * Same as #htmlNodeDumpFormatOutput with `format` set to 1 which is
+ * typically undesired. Use of this function is DISCOURAGED in favor
+ * of #htmlNodeDumpFormatOutput.
+ *
+ * @param buf  the HTML buffer output
+ * @param doc  the document (unused)
+ * @param cur  the current node
+ * @param encoding  the encoding string (unused)
+ */
+void
+htmlNodeDumpOutput(xmlOutputBuffer *buf, xmlDoc *doc ATTRIBUTE_UNUSED,
+                   xmlNode *cur, const char *encoding ATTRIBUTE_UNUSED) {
+    htmlNodeDumpInternal(buf, cur, NULL, 1);
+}
+
+/**
+ * Serialize an HTML document to an output buffer.
+ *
+ * @param buf  the HTML buffer output
+ * @param cur  the document
+ * @param encoding  the encoding string (unused)
+ * @param format  should formatting newlines been added
+ */
+void
+htmlDocContentDumpFormatOutput(xmlOutputBuffer *buf, xmlDoc *cur,
+	                       const char *encoding ATTRIBUTE_UNUSED,
+                               int format) {
+    htmlNodeDumpInternal(buf, (xmlNodePtr) cur, NULL, format);
+}
+
+/**
+ * Same as #htmlDocContentDumpFormatOutput with `format` set to 1
+ * which is typically undesired. Use of this function is DISCOURAGED
+ * in favor of #htmlDocContentDumpFormatOutput.
+ *
+ * @param buf  the HTML buffer output
+ * @param cur  the document
+ * @param encoding  the encoding string (unused)
+ */
+void
+htmlDocContentDumpOutput(xmlOutputBuffer *buf, xmlDoc *cur,
+	                 const char *encoding ATTRIBUTE_UNUSED) {
+    htmlNodeDumpInternal(buf, (xmlNodePtr) cur, NULL, 1);
+}
+
+/************************************************************************
+ *									*
+ *		Saving functions front-ends				*
+ *									*
+ ************************************************************************/
+
+/**
+ * Serialize an HTML document to an open `FILE`.
+ *
+ * Uses the encoding of the document. If the document has no
+ * encoding, ASCII with HTML 4.0 named character entities will
+ * be used. This is inefficient compared to UTF-8 and might be
+ * changed in a future version.
+ *
+ * Enables "formatting" unconditionally which is typically
+ * undesired.
+ *
+ * Use of this function is DISCOURAGED in favor of
+ * #htmlNodeDumpFileFormat.
+ *
+ * @param f  the FILE*
+ * @param cur  the document
+ * @returns the number of bytes written or -1 in case of failure.
+ */
+int
+htmlDocDump(FILE *f, xmlDoc *cur) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    xmlInitParser();
+
+    if ((cur == NULL) || (f == NULL)) {
+	return(-1);
+    }
+
+    if (htmlFindOutputEncoder((char *) cur->encoding, &handler) != XML_ERR_OK)
+        return(-1);
+    buf = xmlOutputBufferCreateFile(f, handler);
+    if (buf == NULL) {
+        xmlCharEncCloseFunc(handler);
+        return(-1);
+    }
+    htmlDocContentDumpOutput(buf, cur, NULL);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * Serialize an HTML document to a file.
+ *
+ * Same as #htmlSaveFileFormat with `encoding` set to NULL and
+ * `format` set to 1 which is typically undesired.
+ *
+ * Use of this function is DISCOURAGED in favor of
+ * #htmlSaveFileFormat.
+ *
+ * @param filename  the filename (or URL)
+ * @param cur  the document
+ * @returns the number of bytes written or -1 in case of failure.
+ */
+int
+htmlSaveFile(const char *filename, xmlDoc *cur) {
+    return(htmlSaveFileFormat(filename, cur, NULL, 1));
+}
+
+/**
+ * Serialize an HTML document to a file using a given encoding.
+ *
+ * If `filename` is `"-"`, stdout is used. This is potentially
+ * insecure and might be changed in a future version.
+ *
+ * If encoding is NULL, ASCII with HTML 4.0 named character entities
+ * will be used. This is inefficient compared to UTF-8 and might be
+ * changed in a future version.
+ *
+ * Sets or updates meta tags containing the character encoding.
+ *
+ * @param filename  the filename
+ * @param cur  the document
+ * @param format  should formatting newlines been added
+ * @param encoding  the document encoding (optional)
+ * @returns the number of bytes written or -1 in case of failure.
+ */
+int
+htmlSaveFileFormat(const char *filename, xmlDoc *cur,
+	           const char *encoding, int format) {
+    xmlOutputBufferPtr buf;
+    xmlCharEncodingHandlerPtr handler = NULL;
+    int ret;
+
+    if ((cur == NULL) || (filename == NULL))
+        return(-1);
+
+    xmlInitParser();
+
+    if (htmlFindOutputEncoder(encoding, &handler) != XML_ERR_OK)
+        return(-1);
+
+    /*
+     * save the content to a temp buffer.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
+    if (buf == NULL) {
+        xmlCharEncCloseFunc(handler);
+        return(0);
+    }
+
+    htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
+
+    ret = xmlOutputBufferClose(buf);
+    return(ret);
+}
+
+/**
+ * Serialize an HTML document to a file.
+ *
+ * Same as #htmlSaveFileFormat with `format` set to 1 which is
+ * typically undesired. Also see the warnings there. Use of this
+ * function is DISCOURAGED in favor of #htmlSaveFileFormat.
+ *
+ * @param filename  the filename
+ * @param cur  the document
+ * @param encoding  the document encoding
+ * @returns the number of bytes written or -1 in case of failure.
+ */
+int
+htmlSaveFileEnc(const char *filename, xmlDoc *cur, const char *encoding) {
+    return(htmlSaveFileFormat(filename, cur, encoding, 1));
+}
+
+#endif /* LIBXML_OUTPUT_ENABLED */
+
+#endif /* LIBXML_HTML_ENABLED */

MAINTAINERS.md

@@ -0,0 +1,130 @@
+# Maintainer's Guide
+
+## Working with the test suite
+
+Most of the tests are contained in the `runtest` executable which
+generally reads test cases from the `test` directory and compares output
+to files in the `result` directory.
+
+You can simply add new test cases and run `runtest -u` to update the
+results. If you debug test failures, it's also useful to execute
+`runtest -u` and then `git diff result` to get a diff between actual and
+expected results. You can restore the original results by running
+`git restore result` and `git clean -xd result`.
+
+## Generated files
+
+Some source code is generated with Python scripts in the `tools`
+directory.
+
+- `tools/genChRanges.py` generates code to handle character ranges
+  from chvalid.def:
+  - `chvalid.c`
+  - `include/libxml/chvalid.h`
+
+- `tools/genEscape prints lookup tables for serialization.
+
+- `tools/genHtml5LibTests.py` creates test cases and expected results
+  from the html5lib test suite:
+  - `test/html-tokenizer`
+  - `result/html-tokenizer`
+
+- `tools/genHtmlEnt.py` prints lookup tables for HTML5 named character
+  references (predefined entities):
+  - `html5ent.inc`
+
+- `tools/gentest.py` generates test code using the Doxygen XML output:
+  - `testapi.c`
+
+- `tools/genUnicode.py` generates code to handle Unicode ranges
+  from Unicode data files:
+  - `xmlunicode.c`
+
+## Making a release
+
+### Update the NEWS file
+
+You can get started by running
+
+    git log --format='- %s (%an)' [previous-release-tag]..
+
+### Bump the version number
+
+Update the version number in `VERSION` if you haven't done so already.
+
+### Commit and verify tarball
+
+Release tarballs are generated with a CI job and the `.gitlab-ci/dist.sh`
+script. Push the release commit and inspect the tarball artifact generated
+by Gitlab CI.
+
+### Tag the release
+
+Create an annotated tag and push it:
+
+    git tag -a [version] -m 'Release [version]'
+    git push origin [version]
+
+This will upload the release to the downloads server using the GNOME
+Release Service. For more details, see
+<https://handbook.gnome.org/maintainers/release-pipeline.html>
+
+### Create a GitLab release
+
+Create or update a GitLab release on
+<https://gitlab.gnome.org/GNOME/libxml2/-/releases>.
+
+### Announce the release
+
+Announce the release on https://discourse.gnome.org under topics 'libxml2'
+and 'announcements'.
+
+## Removing public API functions
+
+General process to remove public API functions (or variables):
+
+- Make sure that there's a reasonable alternative.
+- Mark the function as deprecated in the documentation and mention
+  alternatives.
+- Mark the function as XML_DEPRECATED in the header files.
+- For whole modules: disable the module by default and only enable
+  it in "legacy mode".
+- Remove the function body and make the function return an error code
+  or a no-op. Make sure that the symbol is kept and exported. This
+  should only be done after allowing users enough time to adjust.
+- At the next ABI bump, remove the symbol completely.
+
+You can wait for the next feature release between some of the steps to
+make the process more gradual.
+
+## Breaking the ABI
+
+Unfortunately, libxml2 exposes many internal structs which makes some
+beneficial changes impossible without breaking the ABI.
+
+The following changes are allowed (after careful consideration):
+
+- Appending members to structs which client code should never allocate
+  directly. A notable example is xmlParserCtxt. Other structs like
+  xmlError are allocated directly by client code and must not be changed.
+
+- Making a void function return a value.
+
+- Making functions accept const pointers unless it's a typedef for a
+  callback.
+
+- Changing signedness of struct members or function arguments.
+
+## Updating the CI Docker image
+
+Note that the CI image is used for libxslt as well. First create a
+GitLab access token with maintainer role and `read_registry` and
+`write_registry` permissions. Then run the following commands with the
+Dockerfile in the .gitlab-ci directory:
+
+    docker login -u <username> -p <access_token> \
+        registry.gitlab.gnome.org
+    docker build -t registry.gitlab.gnome.org/gnome/libxml2 - \
+        < .gitlab-ci/Dockerfile
+    docker push registry.gitlab.gnome.org/gnome/libxml2
+

Makefile.am

@@ -0,0 +1,241 @@
+## Process this file with automake to produce Makefile.in
+
+ACLOCAL_AMFLAGS = -I m4
+
+SUBDIRS = include . example
+if WITH_DOXYGEN
+SUBDIRS += doc
+endif
+if WITH_PYTHON
+SUBDIRS += python
+endif
+if WITH_GLOB
+SUBDIRS += fuzz
+endif
+
+DIST_SUBDIRS = include . doc example fuzz python
+
+AM_CPPFLAGS = -I$(builddir)/include -I$(srcdir)/include
+
+check_PROGRAMS = \
+	runsuite \
+	runtest \
+	runxmlconf \
+	testModule \
+	testapi \
+	testchar \
+	testdict \
+	testlimits \
+	testparser \
+	testrecurse
+
+bin_PROGRAMS = xmllint
+
+bin_SCRIPTS = xml2-config
+
+lib_LTLIBRARIES = libxml2.la
+libxml2_la_CFLAGS = $(AM_CFLAGS) $(XML_PRIVATE_CFLAGS)
+libxml2_la_LIBADD = $(XML_PRIVATE_LIBS)
+
+libxml2_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined \
+		     -version-info $(LIBXML_VERSION_INFO)
+
+libxml2_la_SOURCES = buf.c chvalid.c dict.c entities.c encoding.c error.c \
+		     globals.c hash.c list.c parser.c parserInternals.c \
+		     SAX2.c threads.c tree.c uri.c valid.c xmlIO.c \
+		     xmlmemory.c xmlstring.c
+if WITH_C14N_SOURCES
+libxml2_la_SOURCES += c14n.c
+endif
+if WITH_CATALOG_SOURCES
+if WITH_OUTPUT_SOURCES
+bin_PROGRAMS += xmlcatalog
+
+xmlcatalog_SOURCES = xmlcatalog.c
+xmlcatalog_CFLAGS = $(AM_CFLAGS) $(RDL_CFLAGS)
+xmlcatalog_DEPENDENCIES = $(DEPS)
+xmlcatalog_LDADD = $(RDL_LIBS) $(LDADDS)
+endif
+
+libxml2_la_SOURCES += catalog.c
+endif
+if WITH_DEBUG_SOURCES
+libxml2_la_SOURCES += debugXML.c
+endif
+if WITH_HTML_SOURCES
+libxml2_la_SOURCES += HTMLparser.c HTMLtree.c
+endif
+if WITH_HTTP_SOURCES
+libxml2_la_SOURCES += nanohttp.c
+endif
+if WITH_MODULES_SOURCES
+libxml2_la_SOURCES += xmlmodule.c
+endif
+if WITH_OUTPUT_SOURCES
+libxml2_la_SOURCES += xmlsave.c
+endif
+if WITH_PATTERN_SOURCES
+libxml2_la_SOURCES += pattern.c
+endif
+if WITH_READER_SOURCES
+libxml2_la_SOURCES += xmlreader.c
+endif
+if WITH_REGEXPS_SOURCES
+libxml2_la_SOURCES += xmlregexp.c
+endif
+if WITH_RELAXNG_SOURCES
+libxml2_la_SOURCES += relaxng.c
+endif
+if WITH_SCHEMAS_SOURCES
+libxml2_la_SOURCES += xmlschemas.c xmlschemastypes.c
+endif
+if WITH_SCHEMATRON_SOURCES
+libxml2_la_SOURCES += schematron.c
+endif
+if WITH_WRITER_SOURCES
+libxml2_la_SOURCES += xmlwriter.c
+endif
+if WITH_XINCLUDE_SOURCES
+libxml2_la_SOURCES += xinclude.c
+endif
+if WITH_XPATH_SOURCES
+libxml2_la_SOURCES += xpath.c
+endif
+if WITH_XPTR_SOURCES
+libxml2_la_SOURCES += xlink.c xpointer.c
+endif
+
+DEPS = libxml2.la
+LDADDS = libxml2.la
+
+runtest_SOURCES=runtest.c
+runtest_DEPENDENCIES = $(DEPS)
+runtest_LDADD= $(THREAD_LIBS) $(LDADDS)
+
+testrecurse_SOURCES=testrecurse.c
+testrecurse_DEPENDENCIES = $(DEPS)
+testrecurse_LDADD= $(LDADDS)
+
+testlimits_SOURCES=testlimits.c
+testlimits_DEPENDENCIES = $(DEPS)
+testlimits_LDADD= $(LDADDS)
+
+testchar_SOURCES=testchar.c
+testchar_DEPENDENCIES = $(DEPS)
+testchar_LDADD= $(LDADDS)
+
+testdict_SOURCES=testdict.c
+testdict_DEPENDENCIES = $(DEPS)
+testdict_LDADD= $(LDADDS)
+
+testparser_SOURCES=testparser.c
+testparser_DEPENDENCIES = $(DEPS)
+testparser_LDADD= $(LDADDS)
+
+runsuite_SOURCES=runsuite.c
+runsuite_DEPENDENCIES = $(DEPS)
+runsuite_LDADD= $(LDADDS)
+
+xmllint_SOURCES = xmllint.c shell.c lintmain.c
+xmllint_CFLAGS = $(AM_CFLAGS) $(RDL_CFLAGS)
+xmllint_DEPENDENCIES = $(DEPS)
+xmllint_LDADD=  $(RDL_LIBS) $(LDADDS)
+
+testModule_SOURCES=testModule.c
+testModule_DEPENDENCIES = $(DEPS)
+testModule_LDADD= $(LDADDS)
+
+check_LTLIBRARIES = testdso.la
+testdso_la_SOURCES = testdso.c
+testdso_la_LDFLAGS = $(AM_LDFLAGS) \
+		     -module -no-undefined -avoid-version -rpath $(libdir)
+
+rebuild_testapi:
+	cd $(srcdir) && python3 codegen/genTestApi.py $(abs_builddir)
+
+testapi_SOURCES=testapi.c
+testapi_DEPENDENCIES = $(DEPS)
+testapi_LDADD= $(LDADDS)
+
+runxmlconf_SOURCES=runxmlconf.c
+runxmlconf_DEPENDENCIES = $(DEPS)
+runxmlconf_LDADD= $(LDADDS)
+
+check-local:
+	[ -d test   ] || $(LN_S) $(srcdir)/test   .
+	[ -d result ] || $(LN_S) $(srcdir)/result .
+	$(CHECKER) ./runtest$(EXEEXT)
+	$(CHECKER) ./testrecurse$(EXEEXT)
+	$(CHECKER) ./testapi$(EXEEXT)
+	$(CHECKER) ./testchar$(EXEEXT)
+	$(CHECKER) ./testdict$(EXEEXT)
+	$(CHECKER) ./testparser$(EXEEXT)
+	$(CHECKER) ./testModule$(EXEEXT)
+	$(CHECKER) ./runxmlconf$(EXEEXT) -d $(srcdir)/xmlconf
+	$(CHECKER) ./runsuite$(EXEEXT)
+if WITH_OUTPUT_SOURCES
+if WITH_DEBUG_SOURCES
+	test/scripts/test.sh ./xmllint$(EXEEXT)
+endif
+if WITH_CATALOG_SOURCES
+	ASAN_OPTIONS=detect_leaks=0 test/catalogs/test.sh ./xmlcatalog$(EXEEXT)
+	ASAN_OPTIONS=detect_leaks=0 test/catalogs/test_sgml.sh ./xmlcatalog$(EXEEXT)
+endif
+endif
+
+# Compatibility name of the check target
+runtests: check
+
+check-valgrind valgrind:
+	@echo '## Running the regression tests under Valgrind'
+	@echo '## Go get a cup of coffee it is gonna take a while ...'
+	$(MAKE) CHECKER='valgrind -q' check
+
+dist-hook:
+	(cd $(srcdir) ; tar -cf - --exclude .git win32 test result) | (cd $(distdir); tar xf -)
+
+CLEANFILES = missing.lst runsuite.log runxmlconf.log test.out \
+	     *.gcda *.gcno *.res
+
+EXTRA_DIST = Copyright libxml2-config.cmake.in autogen.sh \
+	     libxml.h \
+	     codegen/charset.inc \
+	     codegen/escape.inc \
+	     codegen/genCharset.py \
+	     codegen/genEscape.py \
+	     codegen/genHtml5Ent.py \
+	     codegen/genHtml5LibTests.py \
+	     codegen/genRanges.py \
+	     codegen/genTestApi.py \
+	     codegen/genUnicode.py \
+	     codegen/html5ent.inc \
+	     codegen/ranges.def \
+	     codegen/ranges.inc \
+	     codegen/rangetab.py \
+	     codegen/unicode.inc \
+	     codegen/xmlmod.py \
+	     timsort.h \
+	     README.zOS README.md \
+	     CMakeLists.txt config.h.cmake.in libxml2-config.cmake.cmake.in \
+	     meson.build meson_options.txt xml2-config-meson
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libxml-2.0.pc
+
+cmakedir = $(libdir)/cmake/libxml2
+cmake_DATA = libxml2-config.cmake
+
+
+## ------------ Unity Test Framework Support -------------
+
+# Pattern rule for Unity test harnesses - add -lm
+tests_%: tests_%.o .libs/libxml2.a unity/unity.o
+	$(CC) $(CFLAGS) $(AM_CFLAGS) $(LDFLAGS) -o $@ tests_$*.o .libs/libxml2.a unity/unity.o -lm
+
+# Build test objects
+tests_%.o: tests/tests_%.c
+	$(CC) $(CFLAGS) $(AM_CFLAGS) -I$(srcdir)/include -I. -c -o $@ tests/tests_$*.c
+
+CLEANFILES += tests_*.o tests_* unity/*.o
+
+## ------------ End Unity Test Framework Support -------------

README.md

@@ -0,0 +1,182 @@
+# libxml2
+
+libxml2 is an XML toolkit implemented in C, originally developed for
+the GNOME Project.
+
+Official releases can be downloaded from
+<https://download.gnome.org/sources/libxml2/>
+
+The git repository is hosted on GNOME's GitLab server:
+<https://gitlab.gnome.org/GNOME/libxml2>
+
+Bugs should be reported at
+<https://gitlab.gnome.org/GNOME/libxml2/-/issues>.
+
+Documentation is available at
+<https://gitlab.gnome.org/GNOME/libxml2/-/wikis>
+
+## License
+
+This code is released under the MIT License, see the Copyright file.
+
+## Security
+
+This is open-source software written by hobbyists, maintained by a single
+volunteer, badly tested, written in a memory-unsafe language and full of
+security bugs. It is foolish to use this software to process untrusted data.
+As such, we treat security issues like any other bug. Each security report
+we receive will be made public immediately and won't be prioritized.
+
+## Build instructions
+
+libxml2 can be built with GNU Autotools, CMake or meson.
+
+### Autotools (for POSIX systems like Linux, BSD, macOS)
+
+If you build from a Git tree, you have to install Autotools and start
+by generating the configuration files with:
+
+    ./autogen.sh [configuration options]
+
+If you build from a source tarball, extract the archive with:
+
+    tar xf libxml2-xxx.tar.gz
+    cd libxml2-xxx
+
+Then you can configure and build the library:
+
+    ./configure [configuration options]
+    make
+
+The following options disable or enable code modules and relevant symbols:
+
+    --with-c14n             Canonical XML 1.0 support (on)
+    --with-catalog          XML Catalogs support (on)
+    --with-debug            debugging module (on)
+    --with-docs             Build documentation (off)
+    --with-history          history support for xmllint shell (off)
+    --with-readline[=DIR]   use readline in DIR for shell (off)
+    --with-html             HTML parser (on)
+    --with-http             ABI compatibility for removed HTTP support (off)
+    --with-iconv[=DIR]      iconv support (on)
+    --with-icu              ICU support (off)
+    --with-iso8859x         ISO-8859-X support if no iconv (on)
+    --with-modules          dynamic modules support (on)
+    --with-output           serialization support (on)
+    --with-pattern          xmlPattern selection interface (on)
+    --with-push             push parser interfaces (on)
+    --with-python           Python bindings (off)
+    --with-reader           xmlReader parsing interface (on)
+    --with-regexps          regular expressions support (on)
+    --with-relaxng          RELAX NG support (on)
+    --with-sax1             older SAX1 interface (on)
+    --with-schemas          XML Schemas 1.0 support (on)
+    --with-schematron       Schematron support (off)
+    --with-threads          multithreading support (on)
+    --with-thread-alloc     per-thread malloc hooks (off)
+    --with-valid            DTD validation support (on)
+    --with-writer           xmlWriter serialization interface (on)
+    --with-xinclude         XInclude 1.0 support (on)
+    --with-xpath            XPath 1.0 support (on)
+    --with-xptr             XPointer support (on)
+    --with-zlib[=DIR]       use libz in DIR (off)
+
+Other options:
+
+    --prefix=DIR            set installation prefix
+    --with-minimum          build a minimally sized library (off)
+    --with-legacy           maximum ABI compatibility (off)
+
+Note that by default, no optimization options are used. You have to
+enable them manually, for example with:
+
+    CFLAGS='-O2 -fno-semantic-interposition' ./configure
+
+Now you can run the test suite with:
+
+    make check
+
+Please report test failures to the bug tracker.
+
+Then you can install the library:
+
+    make install
+
+At that point you may have to rerun ldconfig or a similar utility to
+update your list of installed shared libs.
+
+### CMake (mainly for Windows)
+
+Example commands:
+
+    cmake -E tar xf libxml2-xxx.tar.xz
+    cmake -S libxml2-xxx -B builddir [options]
+    cmake --build builddir
+    ctest --test-dir builddir
+    cmake --install builddir
+
+Common CMake options include:
+
+    -D BUILD_SHARED_LIBS=OFF            # build static libraries
+    -D CMAKE_BUILD_TYPE=Release         # specify build type (single-config)
+    --config Release                    # specify build type (multi-config)
+    -D CMAKE_INSTALL_PREFIX=/usr/local  # specify the install path
+    -D LIBXML2_WITH_ICONV=OFF           # disable iconv
+    -D LIBXML2_WITH_ZLIB=ON             # enable zlib
+
+You can also open the libxml source directory with its CMakeLists.txt
+directly in various IDEs such as CLion, QtCreator, or Visual Studio.
+
+### Meson
+
+Example commands:
+
+    meson setup [options] builddir
+    ninja -C builddir
+    meson test -C builddir
+    ninja -C builddir install
+
+See the `meson_options.txt` file for options. For example:
+
+    -Dprefix=$prefix
+    -Dhistory=enabled
+    -Dschemas=disabled
+    -Dzlib=enabled
+
+## Dependencies
+
+libxml2 supports POSIX and Windows operating systems.
+
+The iconv function is required for conversion of character encodings.
+This function is part of POSIX.1-2001. If your platform doesn't provide
+iconv, you need an external libiconv library, for example
+[GNU libiconv](https://www.gnu.org/software/libiconv/). Using
+[ICU](https://icu.unicode.org/) is also supported but discouraged.
+
+The xmllint executable uses libreadline and libhistory if enabled.
+
+### Build requirements
+
+Besides build system tools, only a C compiler should be required.
+Reconfiguration of the Autotools build requires the pkg.m4 macro from
+pkg-config. Building the documentation requires Doxygen, xsltproc and the
+DocBook 4 XSLT stylesheets. Building the Python bindings requires Doxygen.
+
+## Contributing
+
+The current version of the code can be found in GNOME's GitLab at
+<https://gitlab.gnome.org/GNOME/libxml2>. The best way to get involved
+is by creating issues and merge requests on GitLab.
+
+All code must conform to C89 and pass the GitLab CI tests. Add regression
+tests if possible.
+
+## Authors
+
+- Daniel Veillard
+- Bjorn Reese
+- William Brack
+- Igor Zlatkovic for the Windows port
+- Aleksey Sanin
+- Nick Wellnhofer
+

README.zOS

@@ -0,0 +1,212 @@
+Notes for compiling on zOS:
+
+- since testapi.c file is huge (over 52000 lines), it's compilation
+  fails: I skipped the problem by removing all references to testapi in the
+  Makefile.in, but it would be neater if one can build without test files
+  (I didn't find an option in configure...)
+
+- since the name of files (or qualifier) in PDS are limited to 8 I had to
+  rename xmlschemas.c and xmlschemastypes.c in (resp.) xmlsche.c xmlschet.c
+  (and I had to modify all occurrences of these files accordingly in the
+  rest of the Makefile !!!).
+
+- in order to copy objects to PDS, I had the cp command at line 860
+  of Makefile.in
+
+libxml2.la: $(libxml2_la_OBJECTS) $(libxml2_la_DEPENDENCIES)
+        $(AM_V_CCLD)$(libxml2_la_LINK) -rpath $(libdir) $(libxml2_la_OBJECTS) $(libxml2_la_LIBADD) $(LIBS)
+        # Copy objects to PDS
+        @list='$(libxml2_OBJECTS)' ; for p in $$list; do \
+          cp -ACMv $$p "//'<PDS NAME>'"; \
+        done
+
+	with <PDS NAME> stands for the name of my PDS and
+	
+libxml2_OBJECTS = SAX.o entities.o encoding.o error.o \
+	parserInternals.o parser.o tree.o hash.o list.o xmlIO.o \
+	xmlmemory.o uri.o valid.o xlink.o HTMLparser.o \
+	HTMLtree.o debugXML.o xpath.o xpointer.o xinclude.o \
+	nanohttp.o nanoftp.o triostr.o trio.o catalog.o globals.o \
+	threads.o c14n.o xmlstring.o buf.o xmlregexp.o \
+	xmlsche.o xmlschet.o xmlunicode.o \
+	xmlreader.o relaxng.o dict.o SAX2.o \
+	xmlwriter.o legacy.o chvalid.o pattern.o xmlsave.o \
+	xmlmodule.o schematron.o xzlib.o 
+
+In order to handle the support of zOS without breaking the existing
+Makefile maybe a new option/flag zOs would copy xmlschemas.c and
+xmlschemastypes.c files and use specifics targets rather than existing
+ones with the longer names... A variable to handle the PDS name has to
+be provided also...
+
+See patch below for set of changes to Makefile.in
+
+Stéphane Michaut <smichaut@axway.com>
+July 2017
+
+
+--- Makefile.in	2017-08-01 08:17:15.000000000 +0200
++++ Makefile-new.in	2017-08-01 08:07:26.000000000 +0200
+@@ -41,7 +41,7 @@
+ 	testSAX$(EXEEXT) testHTML$(EXEEXT) testXPath$(EXEEXT) \
+ 	testURI$(EXEEXT) testThreads$(EXEEXT) testC14N$(EXEEXT) \
+ 	testAutomata$(EXEEXT) testRegexp$(EXEEXT) testReader$(EXEEXT) \
+-	testapi$(EXEEXT) testModule$(EXEEXT) runtest$(EXEEXT) \
++	testModule$(EXEEXT) runtest$(EXEEXT) \
+ 	runsuite$(EXEEXT) testchar$(EXEEXT) testdict$(EXEEXT) \
+ 	runxmlconf$(EXEEXT) testrecurse$(EXEEXT) testlimits$(EXEEXT)
+ bin_PROGRAMS = xmllint$(EXEEXT) xmlcatalog$(EXEEXT)
+@@ -106,6 +106,7 @@
+ 	debugXML.c xpath.c xpointer.c xinclude.c nanohttp.c nanoftp.c \
+ 	DOCBparser.c catalog.c globals.c threads.c c14n.c xmlstring.c \
+ 	buf.c xmlregexp.c xmlschemas.c xmlschemastypes.c xmlunicode.c \
++        xmlsche.c xmlschet.c \
+ 	triostr.c trio.c xmlreader.c relaxng.c dict.c SAX2.c \
+ 	xmlwriter.c legacy.c chvalid.c pattern.c xmlsave.c xmlmodule.c \
+ 	schematron.c xzlib.c
+@@ -118,10 +119,24 @@
+ 	nanohttp.lo nanoftp.lo $(am__objects_1) catalog.lo globals.lo \
+ 	threads.lo c14n.lo xmlstring.lo buf.lo xmlregexp.lo \
+ 	xmlschemas.lo xmlschemastypes.lo xmlunicode.lo \
++        xmlsche.lo xmlschet.lo \
+ 	$(am__objects_2) xmlreader.lo relaxng.lo dict.lo SAX2.lo \
+ 	xmlwriter.lo legacy.lo chvalid.lo pattern.lo xmlsave.lo \
+ 	xmlmodule.lo schematron.lo xzlib.lo
+ libxml2_la_OBJECTS = $(am_libxml2_la_OBJECTS)
++
++libxml2_OBJECTS = SAX.o entities.o encoding.o error.o \
++	parserInternals.o parser.o tree.o hash.o list.o xmlIO.o \
++	xmlmemory.o uri.o valid.o xlink.o HTMLparser.o \
++	HTMLtree.o debugXML.o xpath.o xpointer.o xinclude.o \
++	nanohttp.o nanoftp.o triostr.o trio.o catalog.o globals.o \
++	threads.o c14n.o xmlstring.o buf.o xmlregexp.o \
++	xmlschemas.o xmlschemastypes.o xmlunicode.o \
++	xmlsche.o xmlschemast.o \
++	xmlreader.o relaxng.o dict.o SAX2.o \
++	xmlwriter.o legacy.o chvalid.o pattern.o xmlsave.o \
++	xmlmodule.o schematron.o xzlib.o
++
+ AM_V_lt = $(am__v_lt_$(V))
+ am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY))
+ am__v_lt_0 = --silent
+@@ -216,11 +231,6 @@
+ testXPath_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+ 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+ 	$(testXPath_LDFLAGS) $(LDFLAGS) -o $@
+-am_testapi_OBJECTS = testapi.$(OBJEXT)
+-testapi_OBJECTS = $(am_testapi_OBJECTS)
+-testapi_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+-	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+-	$(testapi_LDFLAGS) $(LDFLAGS) -o $@
+ am_testchar_OBJECTS = testchar.$(OBJEXT)
+ testchar_OBJECTS = $(am_testchar_OBJECTS)
+ testchar_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+@@ -285,7 +295,7 @@
+ 	$(testReader_SOURCES) $(testRegexp_SOURCES) \
+ 	$(testRelax_SOURCES) $(testSAX_SOURCES) $(testSchemas_SOURCES) \
+ 	$(testThreads_SOURCES) $(testURI_SOURCES) $(testXPath_SOURCES) \
+-	$(testapi_SOURCES) $(testchar_SOURCES) $(testdict_SOURCES) \
++	$(testchar_SOURCES) $(testdict_SOURCES) \
+ 	$(testlimits_SOURCES) $(testrecurse_SOURCES) \
+ 	$(xmlcatalog_SOURCES) $(xmllint_SOURCES)
+ DIST_SOURCES = $(am__libxml2_la_SOURCES_DIST) $(testdso_la_SOURCES) \
+@@ -295,7 +305,7 @@
+ 	$(testReader_SOURCES) $(testRegexp_SOURCES) \
+ 	$(testRelax_SOURCES) $(testSAX_SOURCES) $(testSchemas_SOURCES) \
+ 	$(am__testThreads_SOURCES_DIST) $(testURI_SOURCES) \
+-	$(testXPath_SOURCES) $(testapi_SOURCES) $(testchar_SOURCES) \
++	$(testXPath_SOURCES) $(testchar_SOURCES) \
+ 	$(testdict_SOURCES) $(testlimits_SOURCES) \
+ 	$(testrecurse_SOURCES) $(xmlcatalog_SOURCES) \
+ 	$(xmllint_SOURCES)
+@@ -700,11 +710,6 @@
+ noinst_LTLIBRARIES = testdso.la
+ testdso_la_SOURCES = testdso.c
+ testdso_la_LDFLAGS = -module -no-undefined -avoid-version -rpath $(libdir)
+-BUILT_SOURCES = testapi.c
+-testapi_SOURCES = testapi.c
+-testapi_LDFLAGS = 
+-testapi_DEPENDENCIES = $(DEPS)
+-testapi_LDADD = $(LDADDS)
+ runxmlconf_SOURCES = runxmlconf.c
+ runxmlconf_LDFLAGS = 
+ runxmlconf_DEPENDENCIES = $(DEPS)
+@@ -854,6 +859,12 @@
+ 	done
+ libxml2.la: $(libxml2_la_OBJECTS) $(libxml2_la_DEPENDENCIES) 
+ 	$(AM_V_CCLD)$(libxml2_la_LINK) -rpath $(libdir) $(libxml2_la_OBJECTS) $(libxml2_la_LIBADD) $(LIBS)
++        # Copie des obj
++	@list='$(libxml2_OBJECTS)' ; for p in $$list; do \
++	  echo "copy to PDS: $$p"; \
++	  cp -ACMv $$p "//'A009153.XRDEV230.FIC.OBJLIB.LIBXML'"; \
++	done 
++
+ testdso.la: $(testdso_la_OBJECTS) $(testdso_la_DEPENDENCIES) 
+ 	$(AM_V_CCLD)$(testdso_la_LINK)  $(testdso_la_OBJECTS) $(testdso_la_LIBADD) $(LIBS)
+ install-binPROGRAMS: $(bin_PROGRAMS)
+@@ -953,9 +964,6 @@
+ testXPath$(EXEEXT): $(testXPath_OBJECTS) $(testXPath_DEPENDENCIES) 
+ 	@rm -f testXPath$(EXEEXT)
+ 	$(AM_V_CCLD)$(testXPath_LINK) $(testXPath_OBJECTS) $(testXPath_LDADD) $(LIBS)
+-testapi$(EXEEXT): $(testapi_OBJECTS) $(testapi_DEPENDENCIES) 
+-	@rm -f testapi$(EXEEXT)
+-	$(AM_V_CCLD)$(testapi_LINK) $(testapi_OBJECTS) $(testapi_LDADD) $(LIBS)
+ testchar$(EXEEXT): $(testchar_OBJECTS) $(testchar_DEPENDENCIES) 
+ 	@rm -f testchar$(EXEEXT)
+ 	$(AM_V_CCLD)$(testchar_LINK) $(testchar_OBJECTS) $(testchar_LDADD) $(LIBS)
+@@ -1056,7 +1064,6 @@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testThreadsWin32.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testURI.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testXPath.Po@am__quote@
+-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testapi.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testchar.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testdict.Po@am__quote@
+ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/testdso.Plo@am__quote@
+@@ -1755,18 +1762,6 @@
+ 	uninstall-local uninstall-m4dataDATA uninstall-man \
+ 	uninstall-man1 uninstall-man3 uninstall-pkgconfigDATA
+ 
+-
+-# that one forces the rebuild when "make rebuild" is run on doc/
+-rebuild_testapi:
+-	-@(if [ "$(PYTHON)" != "" ] ; then \
+-	    $(PYTHON) $(srcdir)/gentest.py $(srcdir) ; fi )
+-
+-# that one is just to make sure it is rebuilt if missing
+-# but adding the dependances generate mess
+-testapi.c: $(srcdir)/gentest.py
+-	-@(if [ "$(PYTHON)" != "" ] ; then \
+-	    $(PYTHON) $(srcdir)/gentest.py $(srcdir) ; fi )
+-
+ #testOOM_SOURCES=testOOM.c testOOMlib.h testOOMlib.c
+ #testOOM_LDFLAGS = 
+ #testOOM_DEPENDENCIES = $(DEPS)
+@@ -1775,7 +1770,7 @@
+ runtests:
+ 	[ -d test   ] || $(LN_S) $(srcdir)/test   .
+ 	[ -d result ] || $(LN_S) $(srcdir)/result .
+-	$(CHECKER) ./runtest$(EXEEXT) && $(CHECKER) ./testrecurse$(EXEEXT) &&$(CHECKER) ./testapi$(EXEEXT) && $(CHECKER) ./testchar$(EXEEXT)&& $(CHECKER) ./testdict$(EXEEXT) && $(CHECKER) ./runxmlconf$(EXEEXT)
++	$(CHECKER) ./runtest$(EXEEXT) && $(CHECKER) ./testrecurse$(EXEEXT) &&$(CHECKER) && $(CHECKER) ./testchar$(EXEEXT)&& $(CHECKER) ./testdict$(EXEEXT) && $(CHECKER) ./runxmlconf$(EXEEXT)
+ 	@(if [ "$(PYTHON_SUBDIR)" != "" ] ; then cd python ; \
+ 	    $(MAKE) tests ; fi)
+ 
+@@ -1797,10 +1792,6 @@
+ 	    $(MAKE) tests ; fi)
+ 	@(cd doc/examples ; $(MAKE) tests)
+ 
+-APItests: testapi$(EXEEXT)
+-	@echo "## Running the API regression tests this may take a little while"
+-	-@($(CHECKER) $(top_builddir)/testapi -q)
+-
+ HTMLtests : testHTML$(EXEEXT)
+ 	@(echo > .memdump)
+ 	@echo "## HTML regression tests"
+@@ -2746,7 +2737,7 @@
+ dist-test: distdir
+ 	(mkdir -p $(distdir))
+ 	(cd $(srcdir) ; tar -cf - --exclude CVS --exclude .svn --exclude .git xstc/Tests) | (cd $(distdir); tar xf -)
+-	tar -cf - $(distdir)/test $(distdir)/result $(distdir)/xstc/Tests  $(distdir)/Makefile.tests $(distdir)/README $(distdir)/README.tests $(distdir)/AUTHORS $(distdir)/testapi.c $(distdir)/runtest.c $(distdir)/runsuite.c | GZIP=$(GZIP_ENV) gzip -c >`echo "$(distdir)" | sed "s+libxml2+libxml2-tests+"`.tar.gz
++	tar -cf - $(distdir)/test $(distdir)/result $(distdir)/xstc/Tests  $(distdir)/Makefile.tests $(distdir)/README $(distdir)/README.tests $(distdir)/AUTHORS $(distdir)/runtest.c $(distdir)/runsuite.c | GZIP=$(GZIP_ENV) gzip -c >`echo "$(distdir)" | sed "s+libxml2+libxml2-tests+"`.tar.gz
+ 	@(rm -rf $(distdir)/xstc/Test)
+ 
+ cleantar:

SAX2.c

@@ -0,0 +1,2842 @@
+/*
+ * SAX2.c : Default SAX2 handler to build a tree.
+ *
+ * See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+
+#define IN_LIBXML
+#include "libxml.h"
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <stddef.h>
+#include <libxml/SAX2.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/parserInternals.h>
+#include <libxml/valid.h>
+#include <libxml/entities.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xmlIO.h>
+#include <libxml/uri.h>
+#include <libxml/valid.h>
+#include <libxml/HTMLtree.h>
+
+#include "private/error.h"
+#include "private/parser.h"
+#include "private/tree.h"
+
+#ifndef SIZE_MAX
+  #define SIZE_MAX ((size_t) -1)
+#endif
+
+/*
+ * @param ctxt  an XML validation parser context
+ * @param msg  a string to accompany the error message
+ */
+static void
+xmlSAX2ErrMemory(xmlParserCtxtPtr ctxt) {
+    xmlCtxtErrMemory(ctxt);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/**
+ * Handle a validation error
+ *
+ * @param ctxt  an XML validation parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  extra data
+ * @param str2  extra data
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlErrValid(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+            const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_DTD, error, XML_ERR_ERROR,
+               str1, str2, NULL, 0, msg, str1, str2);
+    if (ctxt != NULL)
+	ctxt->valid = 0;
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * Handle a fatal parser error, i.e. violating Well-Formedness constraints
+ *
+ * @param ctxt  an XML parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  an error string
+ * @param str2  an error string
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlFatalErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+               const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_FATAL,
+               str1, str2, NULL, 0, msg, str1, str2);
+}
+
+/**
+ * Handle an xml:id error
+ *
+ * @param ctxt  an XML validation parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  extra data
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlErrId(xmlParserCtxtPtr ctxt, xmlParserErrors error, const char *msg,
+         const xmlChar *str1)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_ERROR,
+               str1, NULL, NULL, 0, msg, str1);
+}
+
+/**
+ * Handle a parser warning
+ *
+ * @param ctxt  an XML parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  an error string
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+               const char *msg, const xmlChar *str1)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER, error, XML_ERR_WARNING,
+               str1, NULL, NULL, 0, msg, str1);
+}
+
+/**
+ * Handle a namespace warning
+ *
+ * @param ctxt  an XML parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  an error string
+ * @param str2  an error string
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlNsWarnMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+             const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_WARNING,
+               str1, str2, NULL, 0, msg, str1, str2);
+}
+
+/**
+ * Provides the public ID e.g. "-//SGMLSOURCE//DTD DEMO//EN"
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns a xmlChar *
+ */
+const xmlChar *
+xmlSAX2GetPublicId(void *ctx ATTRIBUTE_UNUSED)
+{
+    /* xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx; */
+    return(NULL);
+}
+
+/**
+ * Provides the system ID, basically URL or filename e.g.
+ * http://www.sgmlsource.com/dtds/memo.dtd
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns a xmlChar *
+ */
+const xmlChar *
+xmlSAX2GetSystemId(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctx == NULL) || (ctxt->input == NULL)) return(NULL);
+    return((const xmlChar *) ctxt->input->filename);
+}
+
+/**
+ * Provide the line number of the current parsing point.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns an int
+ */
+int
+xmlSAX2GetLineNumber(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
+    return(ctxt->input->line);
+}
+
+/**
+ * Provide the column number of the current parsing point.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns an int
+ */
+int
+xmlSAX2GetColumnNumber(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctx == NULL) || (ctxt->input == NULL)) return(0);
+    return(ctxt->input->col);
+}
+
+/**
+ * Is this document tagged standalone ?
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns 1 if true
+ */
+int
+xmlSAX2IsStandalone(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctx == NULL) || (ctxt->myDoc == NULL)) return(0);
+    return(ctxt->myDoc->standalone == 1);
+}
+
+/**
+ * Does this document has an internal subset
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns 1 if true
+ */
+int
+xmlSAX2HasInternalSubset(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
+    return(ctxt->myDoc->intSubset != NULL);
+}
+
+/**
+ * Does this document has an external subset
+ *
+ * @param ctx  the user data (XML parser context)
+ * @returns 1 if true
+ */
+int
+xmlSAX2HasExternalSubset(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL)) return(0);
+    return(ctxt->myDoc->extSubset != NULL);
+}
+
+/**
+ * Callback on internal subset declaration.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  the root element name
+ * @param publicId  public identifier of the DTD (optional)
+ * @param systemId  system identifier (URL) of the DTD
+ */
+void
+xmlSAX2InternalSubset(void *ctx, const xmlChar *name,
+	       const xmlChar *publicId, const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDtdPtr dtd;
+    if (ctx == NULL) return;
+
+    if (ctxt->myDoc == NULL)
+	return;
+    if ((ctxt->html) && (ctxt->instate != XML_PARSER_MISC))
+        return;
+    dtd = xmlGetIntSubset(ctxt->myDoc);
+    if (dtd != NULL) {
+	xmlUnlinkNode((xmlNodePtr) dtd);
+	xmlFreeDtd(dtd);
+	ctxt->myDoc->intSubset = NULL;
+    }
+    ctxt->myDoc->intSubset =
+	xmlCreateIntSubset(ctxt->myDoc, name, publicId, systemId);
+    if (ctxt->myDoc->intSubset == NULL)
+        xmlSAX2ErrMemory(ctxt);
+}
+
+/**
+ * Callback on external subset declaration.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  the root element name
+ * @param publicId  public identifier of the DTD (optional)
+ * @param systemId  system identifier (URL) of the DTD
+ */
+void
+xmlSAX2ExternalSubset(void *ctx, const xmlChar *name,
+	       const xmlChar *publicId, const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    if (ctx == NULL) return;
+    if ((systemId != NULL) &&
+        ((ctxt->options & XML_PARSE_NO_XXE) == 0) &&
+        (((ctxt->validate) || (ctxt->loadsubset & ~XML_SKIP_IDS)) &&
+	 (ctxt->wellFormed && ctxt->myDoc))) {
+	/*
+	 * Try to fetch and parse the external subset.
+	 */
+	xmlParserInputPtr oldinput;
+	int oldinputNr;
+	int oldinputMax;
+	xmlParserInputPtr *oldinputTab;
+	xmlParserInputPtr input = NULL;
+	xmlChar *oldencoding;
+        unsigned long consumed;
+        size_t buffered;
+#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
+        int inputMax = 1;
+#else
+        int inputMax = 5;
+#endif
+
+	/*
+	 * Ask the Entity resolver to load the damn thing
+	 */
+	if ((ctxt->sax != NULL) && (ctxt->sax->resolveEntity != NULL))
+	    input = ctxt->sax->resolveEntity(ctxt->userData, publicId,
+	                                     systemId);
+	if (input == NULL) {
+	    return;
+	}
+
+	if (xmlNewDtd(ctxt->myDoc, name, publicId, systemId) == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+            xmlFreeInputStream(input);
+            return;
+        }
+
+	/*
+	 * make sure we won't destroy the main document context
+	 */
+	oldinput = ctxt->input;
+	oldinputNr = ctxt->inputNr;
+	oldinputMax = ctxt->inputMax;
+	oldinputTab = ctxt->inputTab;
+	oldencoding = ctxt->encoding;
+	ctxt->encoding = NULL;
+
+	ctxt->inputTab = xmlMalloc(inputMax * sizeof(xmlParserInputPtr));
+	if (ctxt->inputTab == NULL) {
+	    xmlSAX2ErrMemory(ctxt);
+            goto error;
+	}
+	ctxt->inputNr = 0;
+	ctxt->inputMax = inputMax;
+	ctxt->input = NULL;
+	if (xmlCtxtPushInput(ctxt, input) < 0)
+            goto error;
+
+	if (input->filename == NULL)
+	    input->filename = (char *) xmlCanonicPath(systemId);
+	input->line = 1;
+	input->col = 1;
+	input->base = ctxt->input->cur;
+	input->cur = ctxt->input->cur;
+	input->free = NULL;
+
+	/*
+	 * let's parse that entity knowing it's an external subset.
+	 */
+	xmlParseExternalSubset(ctxt, publicId, systemId);
+
+        /*
+	 * Free up the external entities
+	 */
+
+	while (ctxt->inputNr > 1)
+	    xmlFreeInputStream(xmlCtxtPopInput(ctxt));
+
+        consumed = ctxt->input->consumed;
+        buffered = ctxt->input->cur - ctxt->input->base;
+        if (buffered > ULONG_MAX - consumed)
+            consumed = ULONG_MAX;
+        else
+            consumed += buffered;
+        if (consumed > ULONG_MAX - ctxt->sizeentities)
+            ctxt->sizeentities = ULONG_MAX;
+        else
+            ctxt->sizeentities += consumed;
+
+error:
+	xmlFreeInputStream(input);
+        xmlFree(ctxt->inputTab);
+
+	/*
+	 * Restore the parsing context of the main entity
+	 */
+	ctxt->input = oldinput;
+	ctxt->inputNr = oldinputNr;
+	ctxt->inputMax = oldinputMax;
+	ctxt->inputTab = oldinputTab;
+	if (ctxt->encoding != NULL)
+	    xmlFree(ctxt->encoding);
+	ctxt->encoding = oldencoding;
+	/* ctxt->wellFormed = oldwellFormed; */
+    }
+}
+
+/**
+ * This is only used to load DTDs. The preferred way to install
+ * custom resolvers is #xmlCtxtSetResourceLoader.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param publicId  The public ID of the entity
+ * @param systemId  The system ID (URL) of the entity
+ * @returns a parser input.
+ */
+xmlParserInput *
+xmlSAX2ResolveEntity(void *ctx, const xmlChar *publicId,
+                     const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlParserInputPtr ret = NULL;
+    xmlChar *URI = NULL;
+
+    if (ctx == NULL) return(NULL);
+
+    if (systemId != NULL) {
+        const xmlChar *base = NULL;
+        int res;
+
+        if (ctxt->input != NULL)
+            base = BAD_CAST ctxt->input->filename;
+
+        /*
+         * We don't really need the 'directory' struct member, but some
+         * users set it manually to a base URI for memory streams.
+         */
+        if (base == NULL)
+            base = BAD_CAST ctxt->directory;
+
+        if ((xmlStrlen(systemId) > XML_MAX_URI_LENGTH) ||
+            (xmlStrlen(base) > XML_MAX_URI_LENGTH)) {
+            xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT, "URI too long");
+            return(NULL);
+        }
+        res = xmlBuildURISafe(systemId, base, &URI);
+        if (URI == NULL) {
+            if (res < 0)
+                xmlSAX2ErrMemory(ctxt);
+            else
+                xmlWarnMsg(ctxt, XML_ERR_INVALID_URI,
+                           "Can't resolve URI: %s\n", systemId);
+            return(NULL);
+        }
+        if (xmlStrlen(URI) > XML_MAX_URI_LENGTH) {
+            xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT, "URI too long");
+            xmlFree(URI);
+            return(NULL);
+        }
+    }
+
+    ret = xmlLoadResource(ctxt, (const char *) URI,
+                          (const char *) publicId, XML_RESOURCE_DTD);
+
+    xmlFree(URI);
+    return(ret);
+}
+
+/**
+ * Get an entity by name
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The entity name
+ * @returns the xmlEntity if found.
+ */
+xmlEntity *
+xmlSAX2GetEntity(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlEntityPtr ret = NULL;
+
+    if (ctx == NULL) return(NULL);
+
+    if (ctxt->inSubset == 0) {
+	ret = xmlGetPredefinedEntity(name);
+	if (ret != NULL)
+	    return(ret);
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->standalone == 1)) {
+	if (ctxt->inSubset == 2) {
+	    ctxt->myDoc->standalone = 0;
+	    ret = xmlGetDocEntity(ctxt->myDoc, name);
+	    ctxt->myDoc->standalone = 1;
+	} else {
+	    ret = xmlGetDocEntity(ctxt->myDoc, name);
+	    if (ret == NULL) {
+		ctxt->myDoc->standalone = 0;
+		ret = xmlGetDocEntity(ctxt->myDoc, name);
+		if (ret != NULL) {
+		    xmlFatalErrMsg(ctxt, XML_ERR_NOT_STANDALONE,
+	 "Entity(%s) document marked standalone but requires external subset\n",
+				   name, NULL);
+		}
+		ctxt->myDoc->standalone = 1;
+	    }
+	}
+    } else {
+	ret = xmlGetDocEntity(ctxt->myDoc, name);
+    }
+    return(ret);
+}
+
+/**
+ * Get a parameter entity by name
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The entity name
+ * @returns the xmlEntity if found.
+ */
+xmlEntity *
+xmlSAX2GetParameterEntity(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlEntityPtr ret;
+
+    if (ctx == NULL) return(NULL);
+
+    ret = xmlGetParameterEntity(ctxt->myDoc, name);
+    return(ret);
+}
+
+
+/**
+ * An entity definition has been parsed
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  the entity name
+ * @param type  the entity type
+ * @param publicId  The public ID of the entity
+ * @param systemId  The system ID of the entity
+ * @param content  the entity value (without processing).
+ */
+void
+xmlSAX2EntityDecl(void *ctx, const xmlChar *name, int type,
+          const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)
+{
+    xmlEntityPtr ent;
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    int extSubset;
+    int res;
+
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
+        return;
+
+    extSubset = ctxt->inSubset == 2;
+    res = xmlAddEntity(ctxt->myDoc, extSubset, name, type, publicId, systemId,
+                       content, &ent);
+    switch (res) {
+        case XML_ERR_OK:
+            break;
+        case XML_ERR_NO_MEMORY:
+            xmlSAX2ErrMemory(ctxt);
+            return;
+        case XML_WAR_ENTITY_REDEFINED:
+            if (ctxt->pedantic) {
+                if (extSubset)
+                    xmlWarnMsg(ctxt, res, "Entity(%s) already defined in the"
+                               " external subset\n", name);
+                else
+                    xmlWarnMsg(ctxt, res, "Entity(%s) already defined in the"
+                               " internal subset\n", name);
+            }
+            return;
+        case XML_ERR_REDECL_PREDEF_ENTITY:
+            /*
+             * Technically an error but it's a common mistake to get double
+             * escaping according to "4.6 Predefined Entities" wrong.
+             */
+            xmlWarnMsg(ctxt, res, "Invalid redeclaration of predefined"
+                       " entity '%s'", name);
+            return;
+        default:
+            xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
+                           "Unexpected error code from xmlAddEntity\n",
+                           NULL, NULL);
+            return;
+    }
+
+    if ((ent->URI == NULL) && (systemId != NULL)) {
+        xmlChar *URI;
+        const char *base = NULL;
+        int i;
+
+        for (i = ctxt->inputNr - 1; i >= 0; i--) {
+            if (ctxt->inputTab[i]->filename != NULL) {
+                base = ctxt->inputTab[i]->filename;
+                break;
+            }
+        }
+
+        /*
+         * We don't really need the 'directory' struct member, but some
+         * users set it manually to a base URI for memory streams.
+         */
+        if (base == NULL)
+            base = ctxt->directory;
+
+        res = xmlBuildURISafe(systemId, (const xmlChar *) base, &URI);
+
+        if (URI == NULL) {
+            if (res < 0) {
+                xmlSAX2ErrMemory(ctxt);
+            } else {
+                xmlWarnMsg(ctxt, XML_ERR_INVALID_URI,
+                           "Can't resolve URI: %s\n", systemId);
+            }
+        } else if (xmlStrlen(URI) > XML_MAX_URI_LENGTH) {
+            xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT, "URI too long");
+            xmlFree(URI);
+        } else {
+            ent->URI = URI;
+        }
+    }
+}
+
+/**
+ * An attribute definition has been parsed
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param elem  the name of the element
+ * @param fullname  the attribute name
+ * @param type  the attribute type
+ * @param def  the type of default value
+ * @param defaultValue  the attribute default value
+ * @param tree  the tree of enumerated value set
+ */
+void
+xmlSAX2AttributeDecl(void *ctx, const xmlChar *elem, const xmlChar *fullname,
+              int type, int def, const xmlChar *defaultValue,
+	      xmlEnumeration *tree)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlAttributePtr attr;
+    const xmlChar *name = NULL;
+    xmlChar *prefix = NULL;
+
+    /* Avoid unused variable warning if features are disabled. */
+    (void) attr;
+
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
+        return;
+
+    if ((xmlStrEqual(fullname, BAD_CAST "xml:id")) &&
+        (type != XML_ATTRIBUTE_ID)) {
+	xmlErrId(ctxt, XML_DTD_XMLID_TYPE,
+	      "xml:id : attribute type should be ID\n", NULL);
+    }
+    name = xmlSplitQName4(fullname, &prefix);
+    if (name == NULL)
+        xmlSAX2ErrMemory(ctxt);
+    ctxt->vctxt.valid = 1;
+    if (ctxt->inSubset == 1)
+	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, elem,
+	       name, prefix, (xmlAttributeType) type,
+	       (xmlAttributeDefault) def, defaultValue, tree);
+    else if (ctxt->inSubset == 2)
+	attr = xmlAddAttributeDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, elem,
+	   name, prefix, (xmlAttributeType) type,
+	   (xmlAttributeDefault) def, defaultValue, tree);
+    else {
+        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
+	     "SAX.xmlSAX2AttributeDecl(%s) called while not in subset\n",
+	               name, NULL);
+	xmlFree(prefix);
+	xmlFreeEnumeration(tree);
+	return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->vctxt.valid == 0)
+	ctxt->valid = 0;
+    if ((attr != NULL) && (ctxt->validate) && (ctxt->wellFormed) &&
+        (ctxt->myDoc->intSubset != NULL))
+	ctxt->valid &= xmlValidateAttributeDecl(&ctxt->vctxt, ctxt->myDoc,
+	                                        attr);
+#endif /* LIBXML_VALID_ENABLED */
+    if (prefix != NULL)
+	xmlFree(prefix);
+}
+
+/**
+ * An element definition has been parsed
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  the element name
+ * @param type  the element type
+ * @param content  the element value tree
+ */
+void
+xmlSAX2ElementDecl(void *ctx, const xmlChar * name, int type,
+            xmlElementContent *content)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlElementPtr elem = NULL;
+
+    /* Avoid unused variable warning if features are disabled. */
+    (void) elem;
+
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
+        return;
+
+    if (ctxt->inSubset == 1)
+        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->intSubset,
+                                 name, (xmlElementTypeVal) type, content);
+    else if (ctxt->inSubset == 2)
+        elem = xmlAddElementDecl(&ctxt->vctxt, ctxt->myDoc->extSubset,
+                                 name, (xmlElementTypeVal) type, content);
+    else {
+        xmlFatalErrMsg(ctxt, XML_ERR_INTERNAL_ERROR,
+	     "SAX.xmlSAX2ElementDecl(%s) called while not in subset\n",
+	               name, NULL);
+        return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (elem == NULL)
+        ctxt->valid = 0;
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &=
+            xmlValidateElementDecl(&ctxt->vctxt, ctxt->myDoc, elem);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * What to do when a notation declaration has been parsed.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The name of the notation
+ * @param publicId  The public ID of the entity
+ * @param systemId  The system ID of the entity
+ */
+void
+xmlSAX2NotationDecl(void *ctx, const xmlChar *name,
+	     const xmlChar *publicId, const xmlChar *systemId)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNotationPtr nota = NULL;
+
+    /* Avoid unused variable warning if features are disabled. */
+    (void) nota;
+
+    if ((ctxt == NULL) || (ctxt->myDoc == NULL))
+        return;
+
+    if ((publicId == NULL) && (systemId == NULL)) {
+	xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
+	     "SAX.xmlSAX2NotationDecl(%s) externalID or PublicID missing\n",
+	               name, NULL);
+	return;
+    } else if (ctxt->inSubset == 1)
+	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->intSubset, name,
+                              publicId, systemId);
+    else if (ctxt->inSubset == 2)
+	nota = xmlAddNotationDecl(&ctxt->vctxt, ctxt->myDoc->extSubset, name,
+                              publicId, systemId);
+    else {
+	xmlFatalErrMsg(ctxt, XML_ERR_NOTATION_PROCESSING,
+	     "SAX.xmlSAX2NotationDecl(%s) called while not in subset\n",
+	               name, NULL);
+	return;
+    }
+#ifdef LIBXML_VALID_ENABLED
+    if (nota == NULL) ctxt->valid = 0;
+    if ((ctxt->validate) && (ctxt->wellFormed) &&
+        (ctxt->myDoc->intSubset != NULL))
+	ctxt->valid &= xmlValidateNotationDecl(&ctxt->vctxt, ctxt->myDoc,
+	                                       nota);
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * What to do when an unparsed entity declaration is parsed
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The name of the entity
+ * @param publicId  The public ID of the entity
+ * @param systemId  The system ID of the entity
+ * @param notationName  the name of the notation
+ */
+void
+xmlSAX2UnparsedEntityDecl(void *ctx, const xmlChar *name,
+		   const xmlChar *publicId, const xmlChar *systemId,
+		   const xmlChar *notationName)
+{
+    xmlSAX2EntityDecl(ctx, name, XML_EXTERNAL_GENERAL_UNPARSED_ENTITY,
+                      publicId, systemId, (xmlChar *) notationName);
+}
+
+/**
+ * Receive the document locator at startup, actually xmlDefaultSAXLocator
+ * Everything is available on the context, so this is useless in our case.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param loc  A SAX Locator
+ */
+void
+xmlSAX2SetDocumentLocator(void *ctx ATTRIBUTE_UNUSED, xmlSAXLocator *loc ATTRIBUTE_UNUSED)
+{
+}
+
+/**
+ * called when the document start being processed.
+ *
+ * @param ctx  the user data (XML parser context)
+ */
+void
+xmlSAX2StartDocument(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDocPtr doc;
+
+    if (ctx == NULL) return;
+
+#ifdef LIBXML_HTML_ENABLED
+    if (ctxt->html) {
+	if (ctxt->myDoc == NULL)
+	    ctxt->myDoc = htmlNewDocNoDtD(NULL, NULL);
+	if (ctxt->myDoc == NULL) {
+	    xmlSAX2ErrMemory(ctxt);
+	    return;
+	}
+	ctxt->myDoc->properties = XML_DOC_HTML;
+	ctxt->myDoc->parseFlags = ctxt->options;
+    } else
+#endif
+    {
+	doc = ctxt->myDoc = xmlNewDoc(ctxt->version);
+	if (doc != NULL) {
+	    doc->properties = 0;
+	    if (ctxt->options & XML_PARSE_OLD10)
+	        doc->properties |= XML_DOC_OLD10;
+	    doc->parseFlags = ctxt->options;
+	    doc->standalone = ctxt->standalone;
+	} else {
+	    xmlSAX2ErrMemory(ctxt);
+	    return;
+	}
+	if ((ctxt->dictNames) && (doc != NULL)) {
+	    doc->dict = ctxt->dict;
+	    xmlDictReference(doc->dict);
+	}
+    }
+    if ((ctxt->myDoc != NULL) && (ctxt->myDoc->URL == NULL) &&
+	(ctxt->input != NULL) && (ctxt->input->filename != NULL)) {
+	ctxt->myDoc->URL = xmlPathToURI((const xmlChar *)ctxt->input->filename);
+	if (ctxt->myDoc->URL == NULL)
+	    xmlSAX2ErrMemory(ctxt);
+    }
+}
+
+/**
+ * called when the document end has been detected.
+ *
+ * @param ctx  the user data (XML parser context)
+ */
+void
+xmlSAX2EndDocument(void *ctx)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlDocPtr doc;
+
+    if (ctx == NULL) return;
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+	ctxt->valid &= xmlValidateDocumentFinal(&ctxt->vctxt, ctxt->myDoc);
+#endif /* LIBXML_VALID_ENABLED */
+
+    doc = ctxt->myDoc;
+    if (doc == NULL)
+        return;
+
+    if (doc->encoding == NULL) {
+        const xmlChar *encoding = xmlGetActualEncoding(ctxt);
+
+        if (encoding != NULL) {
+            doc->encoding = xmlStrdup(encoding);
+            if (doc->encoding == NULL)
+                xmlSAX2ErrMemory(ctxt);
+        }
+    }
+
+#ifdef LIBXML_HTML_ENABLED
+    if (ctxt->html) {
+        if (((ctxt->options & HTML_PARSE_NODEFDTD) == 0) &&
+            (doc->intSubset == NULL)) {
+            doc->intSubset = xmlCreateIntSubset(doc, BAD_CAST "html",
+                    BAD_CAST "-//W3C//DTD HTML 4.0 Transitional//EN",
+                    BAD_CAST "http://www.w3.org/TR/REC-html40/loose.dtd");
+            if (doc->intSubset == NULL)
+                xmlSAX2ErrMemory(ctxt);
+        }
+    } else
+#endif /* LIBXML_HTML_ENABLED */
+    {
+        if (ctxt->wellFormed) {
+            doc->properties |= XML_DOC_WELLFORMED;
+            if (ctxt->valid)
+                doc->properties |= XML_DOC_DTDVALID;
+            if (ctxt->nsWellFormed)
+                doc->properties |= XML_DOC_NSVALID;
+        }
+
+        if (ctxt->options & XML_PARSE_OLD10)
+            doc->properties |= XML_DOC_OLD10;
+    }
+}
+
+static void
+xmlSAX2AppendChild(xmlParserCtxtPtr ctxt, xmlNodePtr node) {
+    xmlNodePtr parent;
+    xmlNodePtr last;
+
+    if (ctxt->inSubset == 1) {
+	parent = (xmlNodePtr) ctxt->myDoc->intSubset;
+    } else if (ctxt->inSubset == 2) {
+	parent = (xmlNodePtr) ctxt->myDoc->extSubset;
+    } else {
+        parent = ctxt->node;
+        if (parent == NULL)
+            parent = (xmlNodePtr) ctxt->myDoc;
+    }
+
+    last = parent->last;
+    if (last == NULL) {
+        parent->children = node;
+    } else {
+        last->next = node;
+        node->prev = last;
+    }
+
+    parent->last = node;
+    node->parent = parent;
+
+    if ((node->type != XML_TEXT_NODE) &&
+	(ctxt->input != NULL)) {
+        if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
+            node->line = ctxt->input->line;
+        else
+            node->line = USHRT_MAX;
+    }
+}
+
+#if defined(LIBXML_SAX1_ENABLED)
+/**
+ * Handle a namespace error
+ *
+ * @param ctxt  an XML parser context
+ * @param error  the error number
+ * @param msg  the error message
+ * @param str1  an error string
+ * @param str2  an error string
+ */
+static void LIBXML_ATTR_FORMAT(3,0)
+xmlNsErrMsg(xmlParserCtxtPtr ctxt, xmlParserErrors error,
+            const char *msg, const xmlChar *str1, const xmlChar *str2)
+{
+    xmlCtxtErr(ctxt, NULL, XML_FROM_NAMESPACE, error, XML_ERR_ERROR,
+               str1, str2, NULL, 0, msg, str1, str2);
+}
+
+/**
+ * Handle an attribute that has been read by the parser.
+ *
+ * Deprecated SAX1 interface.
+ *
+ * @param ctxt  the parser context
+ * @param fullname  the attribute name, including namespace prefix
+ * @param value  the attribute value
+ * @param prefix  the namespace prefix
+ */
+static void
+xmlSAX1Attribute(xmlParserCtxtPtr ctxt, const xmlChar *fullname,
+                 const xmlChar *value, const xmlChar *prefix)
+{
+    xmlAttrPtr ret;
+    const xmlChar *name;
+    xmlChar *ns;
+    xmlNsPtr namespace;
+
+    /*
+     * Split the full name into a namespace prefix and the tag name
+     */
+    name = xmlSplitQName4(fullname, &ns);
+    if (name == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    /*
+     * Check whether it's a namespace definition
+     */
+    if ((ns == NULL) &&
+        (name[0] == 'x') && (name[1] == 'm') && (name[2] == 'l') &&
+        (name[3] == 'n') && (name[4] == 's') && (name[5] == 0)) {
+	xmlNsPtr nsret;
+	xmlChar *val;
+
+        /* Avoid unused variable warning if features are disabled. */
+        (void) nsret;
+
+        if (!ctxt->replaceEntities) {
+            /* TODO: normalize if needed */
+	    val = xmlExpandEntitiesInAttValue(ctxt, value, /* normalize */ 0);
+	    if (val == NULL) {
+	        xmlSAX2ErrMemory(ctxt);
+		return;
+	    }
+	} else {
+	    val = (xmlChar *) value;
+	}
+
+	if (val[0] != 0) {
+	    xmlURIPtr uri;
+
+	    if (xmlParseURISafe((const char *)val, &uri) < 0)
+                xmlSAX2ErrMemory(ctxt);
+	    if (uri == NULL) {
+                xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
+                             "xmlns:%s: %s not a valid URI\n", name, value);
+	    } else {
+		if (uri->scheme == NULL) {
+                    xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
+                                 "xmlns:%s: URI %s is not absolute\n",
+                                 name, value);
+		}
+		xmlFreeURI(uri);
+	    }
+	}
+
+	/* a default namespace definition */
+	nsret = xmlNewNs(ctxt->node, val, NULL);
+        if (nsret == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+        }
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * Validate also for namespace decls, they are attributes from
+	 * an XML-1.0 perspective
+	 */
+        else if (ctxt->validate && ctxt->wellFormed &&
+                 ctxt->myDoc && ctxt->myDoc->intSubset) {
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+					   ctxt->node, prefix, nsret, val);
+        }
+#endif /* LIBXML_VALID_ENABLED */
+	if (val != value)
+	    xmlFree(val);
+	return;
+    }
+    if ((ns != NULL) && (ns[0] == 'x') && (ns[1] == 'm') && (ns[2] == 'l') &&
+        (ns[3] == 'n') && (ns[4] == 's') && (ns[5] == 0)) {
+	xmlNsPtr nsret;
+	xmlChar *val;
+
+        /* Avoid unused variable warning if features are disabled. */
+        (void) nsret;
+
+        if (!ctxt->replaceEntities) {
+            /* TODO: normalize if needed */
+	    val = xmlExpandEntitiesInAttValue(ctxt, value, /* normalize */ 0);
+	    if (val == NULL) {
+	        xmlSAX2ErrMemory(ctxt);
+	        xmlFree(ns);
+		return;
+	    }
+	} else {
+	    val = (xmlChar *) value;
+	}
+
+	if (val[0] == 0) {
+	    xmlNsErrMsg(ctxt, XML_NS_ERR_EMPTY,
+		        "Empty namespace name for prefix %s\n", name, NULL);
+	}
+	if ((ctxt->pedantic != 0) && (val[0] != 0)) {
+	    xmlURIPtr uri;
+
+	    if (xmlParseURISafe((const char *)val, &uri) < 0)
+                xmlSAX2ErrMemory(ctxt);
+	    if (uri == NULL) {
+	        xmlNsWarnMsg(ctxt, XML_WAR_NS_URI,
+			 "xmlns:%s: %s not a valid URI\n", name, value);
+	    } else {
+		if (uri->scheme == NULL) {
+		    xmlNsWarnMsg(ctxt, XML_WAR_NS_URI_RELATIVE,
+			   "xmlns:%s: URI %s is not absolute\n", name, value);
+		}
+		xmlFreeURI(uri);
+	    }
+	}
+
+	/* a standard namespace definition */
+	nsret = xmlNewNs(ctxt->node, val, name);
+	xmlFree(ns);
+
+        if (nsret == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+        }
+#ifdef LIBXML_VALID_ENABLED
+	/*
+	 * Validate also for namespace decls, they are attributes from
+	 * an XML-1.0 perspective
+	 */
+        else if (ctxt->validate && ctxt->wellFormed &&
+	         ctxt->myDoc && ctxt->myDoc->intSubset) {
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+					   ctxt->node, prefix, nsret, value);
+        }
+#endif /* LIBXML_VALID_ENABLED */
+	if (val != value)
+	    xmlFree(val);
+	return;
+    }
+
+    if (ns != NULL) {
+        int res;
+
+	res = xmlSearchNsSafe(ctxt->node, ns, &namespace);
+        if (res < 0)
+            xmlSAX2ErrMemory(ctxt);
+
+	if (namespace == NULL) {
+	    xmlNsErrMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+		    "Namespace prefix %s of attribute %s is not defined\n",
+		             ns, name);
+	} else {
+            xmlAttrPtr prop;
+
+            prop = ctxt->node->properties;
+            while (prop != NULL) {
+                if (prop->ns != NULL) {
+                    if ((xmlStrEqual(name, prop->name)) &&
+                        ((namespace == prop->ns) ||
+                         (xmlStrEqual(namespace->href, prop->ns->href)))) {
+                        xmlCtxtErr(ctxt, NULL, XML_FROM_PARSER,
+                                   XML_ERR_ATTRIBUTE_REDEFINED, XML_ERR_FATAL,
+                                   name, NULL, NULL, 0,
+                                   "Attribute %s in %s redefined\n",
+                                   name, namespace->href);
+                        goto error;
+                    }
+                }
+                prop = prop->next;
+            }
+        }
+    } else {
+	namespace = NULL;
+    }
+
+    /* !!!!!! <a toto:arg="" xmlns:toto="http://toto.com"> */
+    ret = xmlNewNsProp(ctxt->node, namespace, name, NULL);
+    if (ret == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        goto error;
+    }
+
+    if (ctxt->replaceEntities == 0) {
+        if (xmlNodeParseAttValue(ret->doc, ret, value, SIZE_MAX, NULL) < 0)
+            xmlSAX2ErrMemory(ctxt);
+    } else if (value != NULL) {
+        ret->children = xmlNewDocText(ctxt->myDoc, value);
+        if (ret->children == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+        } else {
+            ret->last = ret->children;
+            ret->children->parent = (xmlNodePtr) ret;
+        }
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset) {
+
+	/*
+	 * If we don't substitute entities, the validation should be
+	 * done on a value with replaced entities anyway.
+	 */
+        if (!ctxt->replaceEntities) {
+	    xmlChar *val;
+
+            /* TODO: normalize if needed */
+	    val = xmlExpandEntitiesInAttValue(ctxt, value, /* normalize */ 0);
+
+	    if (val == NULL)
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				ctxt->myDoc, ctxt->node, ret, value);
+	    else {
+		xmlChar *nvalnorm;
+
+		/*
+		 * Do the last stage of the attribute normalization
+		 * It need to be done twice ... it's an extra burden related
+		 * to the ability to keep xmlSAX2References in attributes
+		 */
+                nvalnorm = xmlValidCtxtNormalizeAttributeValue(
+                                 &ctxt->vctxt, ctxt->myDoc,
+                                 ctxt->node, fullname, val);
+		if (nvalnorm != NULL) {
+		    xmlFree(val);
+		    val = nvalnorm;
+		}
+
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+			        ctxt->myDoc, ctxt->node, ret, val);
+                xmlFree(val);
+	    }
+	} else {
+            /*
+             * When replacing entities, make sure that IDs in
+             * entities aren't registered. This also shouldn't be
+             * done when entities aren't replaced, but this would
+             * require to rework IDREF checks.
+             */
+            if (ctxt->input->entity != NULL)
+                ctxt->vctxt.flags |= XML_VCTXT_IN_ENTITY;
+
+	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt, ctxt->myDoc,
+					       ctxt->node, ret, value);
+
+            ctxt->vctxt.flags &= ~XML_VCTXT_IN_ENTITY;
+	}
+    } else
+#endif /* LIBXML_VALID_ENABLED */
+           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+               (ctxt->input->entity == NULL) &&
+               /* Don't create IDs containing entity references */
+               (ret->children != NULL) &&
+               (ret->children->type == XML_TEXT_NODE) &&
+               (ret->children->next == NULL)) {
+        xmlChar *content = ret->children->content;
+        /*
+	 * when validating, the ID registration is done at the attribute
+	 * validation level. Otherwise we have to do specific handling here.
+	 */
+	if (xmlStrEqual(fullname, BAD_CAST "xml:id")) {
+	    /*
+	     * Add the xml:id value
+	     *
+	     * Open issue: normalization of the value.
+	     */
+	    if (xmlValidateNCName(content, 1) != 0) {
+	        xmlErrId(ctxt, XML_DTD_XMLID_VALUE,
+		         "xml:id : attribute value %s is not an NCName\n",
+		         content);
+	    }
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
+	} else {
+            int res = xmlIsID(ctxt->myDoc, ctxt->node, ret);
+
+            if (res < 0)
+                xmlCtxtErrMemory(ctxt);
+            else if (res > 0)
+                xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
+            else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
+                xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
+        }
+    }
+
+error:
+    if (ns != NULL)
+	xmlFree(ns);
+}
+
+/*
+ *
+ * Check defaulted attributes from the DTD
+ *
+ * Deprecated SAX1 interface.
+ */
+static void
+xmlCheckDefaultedAttributes(xmlParserCtxtPtr ctxt, const xmlChar *name,
+	const xmlChar *prefix, const xmlChar **atts) {
+    xmlElementPtr elemDecl;
+    const xmlChar *att;
+    int internal = 1;
+    int i;
+
+    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->intSubset, name, prefix);
+    if (elemDecl == NULL) {
+	elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset, name, prefix);
+	internal = 0;
+    }
+
+process_external_subset:
+
+    if (elemDecl != NULL) {
+	xmlAttributePtr attr = elemDecl->attributes;
+
+#ifdef LIBXML_VALID_ENABLED
+        /*
+         * Check against defaulted attributes from the external subset
+         * if the document is stamped as standalone.
+         *
+         * This should be moved to valid.c, but we don't keep track
+         * whether an attribute was defaulted.
+         */
+	if ((ctxt->myDoc->standalone == 1) &&
+	    (ctxt->myDoc->extSubset != NULL) &&
+	    (ctxt->validate)) {
+	    while (attr != NULL) {
+		if ((attr->defaultValue != NULL) &&
+		    (xmlGetDtdQAttrDesc(ctxt->myDoc->extSubset,
+					attr->elem, attr->name,
+					attr->prefix) == attr) &&
+		    (xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+					attr->elem, attr->name,
+					attr->prefix) == NULL)) {
+		    xmlChar *fulln;
+
+		    if (attr->prefix != NULL) {
+			fulln = xmlStrdup(attr->prefix);
+                        if (fulln != NULL)
+			    fulln = xmlStrcat(fulln, BAD_CAST ":");
+                        if (fulln != NULL)
+			    fulln = xmlStrcat(fulln, attr->name);
+		    } else {
+			fulln = xmlStrdup(attr->name);
+		    }
+                    if (fulln == NULL) {
+                        xmlSAX2ErrMemory(ctxt);
+                        break;
+                    }
+
+		    /*
+		     * Check that the attribute is not declared in the
+		     * serialization
+		     */
+		    att = NULL;
+		    if (atts != NULL) {
+			i = 0;
+			att = atts[i];
+			while (att != NULL) {
+			    if (xmlStrEqual(att, fulln))
+				break;
+			    i += 2;
+			    att = atts[i];
+			}
+		    }
+		    if (att == NULL) {
+		        xmlErrValid(ctxt, XML_DTD_STANDALONE_DEFAULTED,
+      "standalone: attribute %s on %s defaulted from external subset\n",
+				    fulln,
+				    attr->elem);
+		    }
+                    xmlFree(fulln);
+		}
+		attr = attr->nexth;
+	    }
+	}
+#endif
+
+	/*
+	 * Actually insert defaulted values when needed
+	 */
+	attr = elemDecl->attributes;
+	while (attr != NULL) {
+	    /*
+	     * Make sure that attributes redefinition occurring in the
+	     * internal subset are not overridden by definitions in the
+	     * external subset.
+	     */
+	    if (attr->defaultValue != NULL) {
+		/*
+		 * the element should be instantiated in the tree if:
+		 *  - this is a namespace prefix
+		 *  - the user required for completion in the tree
+		 *    like XSLT
+		 *  - there isn't already an attribute definition
+		 *    in the internal subset overriding it.
+		 */
+		if (((attr->prefix != NULL) &&
+		     (xmlStrEqual(attr->prefix, BAD_CAST "xmlns"))) ||
+		    ((attr->prefix == NULL) &&
+		     (xmlStrEqual(attr->name, BAD_CAST "xmlns"))) ||
+		    (ctxt->loadsubset & XML_COMPLETE_ATTRS)) {
+		    xmlAttributePtr tst;
+
+		    tst = xmlGetDtdQAttrDesc(ctxt->myDoc->intSubset,
+					     attr->elem, attr->name,
+					     attr->prefix);
+		    if ((tst == attr) || (tst == NULL)) {
+		        xmlChar fn[50];
+			xmlChar *fulln;
+
+                        fulln = xmlBuildQName(attr->name, attr->prefix, fn, 50);
+			if (fulln == NULL) {
+			    xmlSAX2ErrMemory(ctxt);
+			    return;
+			}
+
+			/*
+			 * Check that the attribute is not declared in the
+			 * serialization
+			 */
+			att = NULL;
+			if (atts != NULL) {
+			    i = 0;
+			    att = atts[i];
+			    while (att != NULL) {
+				if (xmlStrEqual(att, fulln))
+				    break;
+				i += 2;
+				att = atts[i];
+			    }
+			}
+			if (att == NULL) {
+			    xmlSAX1Attribute(ctxt, fulln,
+					     attr->defaultValue, prefix);
+			}
+			if ((fulln != fn) && (fulln != attr->name))
+			    xmlFree(fulln);
+		    }
+		}
+	    }
+	    attr = attr->nexth;
+	}
+	if (internal == 1) {
+	    elemDecl = xmlGetDtdQElementDesc(ctxt->myDoc->extSubset,
+		                             name, prefix);
+	    internal = 0;
+	    goto process_external_subset;
+	}
+    }
+}
+
+/**
+ * called when an opening tag has been processed.
+ *
+ * Deprecated SAX1 interface.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param fullname  The element name, including namespace prefix
+ * @param atts  An array of name/value attributes pairs, NULL terminated
+ */
+static void
+xmlSAX1StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNodePtr parent;
+    xmlNsPtr ns;
+    const xmlChar *name;
+    xmlChar *prefix;
+    const xmlChar *att;
+    const xmlChar *value;
+    int i, res;
+
+    if ((ctx == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL)) return;
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * First check on validity:
+     */
+    if (ctxt->validate && (ctxt->myDoc->extSubset == NULL) &&
+        ((ctxt->myDoc->intSubset == NULL) ||
+	 ((ctxt->myDoc->intSubset->notations == NULL) &&
+	  (ctxt->myDoc->intSubset->elements == NULL) &&
+	  (ctxt->myDoc->intSubset->attributes == NULL) &&
+	  (ctxt->myDoc->intSubset->entities == NULL)))) {
+	xmlErrValid(ctxt, XML_ERR_NO_DTD,
+	  "Validation failed: no DTD found !", NULL, NULL);
+	ctxt->validate = 0;
+    }
+#endif
+
+    /*
+     * Split the full name into a namespace prefix and the tag name
+     */
+    name = xmlSplitQName4(fullname, &prefix);
+    if (name == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    /*
+     * Note : the namespace resolution is deferred until the end of the
+     *        attributes parsing, since local namespace can be defined as
+     *        an attribute at this level.
+     */
+    ret = xmlNewDocNode(ctxt->myDoc, NULL, name, NULL);
+    if (ret == NULL) {
+	xmlFree(prefix);
+	xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+    ctxt->nodemem = -1;
+
+    /* Initialize parent before pushing node */
+    parent = ctxt->node;
+    if (parent == NULL)
+        parent = (xmlNodePtr) ctxt->myDoc;
+
+    /*
+     * Link the child element
+     */
+    xmlSAX2AppendChild(ctxt, ret);
+
+    /*
+     * We are parsing a new node.
+     */
+    if (nodePush(ctxt, ret) < 0) {
+        xmlUnlinkNode(ret);
+        xmlFreeNode(ret);
+        if (prefix != NULL)
+            xmlFree(prefix);
+        return;
+    }
+
+    /*
+     * Insert all the defaulted attributes from the DTD especially
+     * namespaces
+     */
+    if ((ctxt->myDoc->intSubset != NULL) ||
+        (ctxt->myDoc->extSubset != NULL)) {
+        xmlCheckDefaultedAttributes(ctxt, name, prefix, atts);
+    }
+
+    /*
+     * process all the attributes whose name start with "xmlns"
+     */
+    if (atts != NULL) {
+        i = 0;
+        att = atts[i++];
+        value = atts[i++];
+        while ((att != NULL) && (value != NULL)) {
+            if ((att[0] == 'x') && (att[1] == 'm') && (att[2] == 'l') &&
+                (att[3] == 'n') && (att[4] == 's'))
+                xmlSAX1Attribute(ctxt, att, value, prefix);
+
+            att = atts[i++];
+            value = atts[i++];
+        }
+    }
+
+    /*
+     * Search the namespace, note that since the attributes have been
+     * processed, the local namespaces are available.
+     */
+    res = xmlSearchNsSafe(ret, prefix, &ns);
+    if (res < 0)
+        xmlSAX2ErrMemory(ctxt);
+    if ((ns == NULL) && (parent != NULL)) {
+        res = xmlSearchNsSafe(parent, prefix, &ns);
+        if (res < 0)
+            xmlSAX2ErrMemory(ctxt);
+    }
+    if ((prefix != NULL) && (ns == NULL)) {
+        xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+                     "Namespace prefix %s is not defined\n",
+                     prefix, NULL);
+        ns = xmlNewNs(ret, NULL, prefix);
+        if (ns == NULL)
+            xmlSAX2ErrMemory(ctxt);
+    }
+
+    /*
+     * set the namespace node, making sure that if the default namespace
+     * is unbound on a parent we simply keep it NULL
+     */
+    if ((ns != NULL) && (ns->href != NULL) &&
+        ((ns->href[0] != 0) || (ns->prefix != NULL)))
+        xmlSetNs(ret, ns);
+
+    /*
+     * process all the other attributes
+     */
+    if (atts != NULL) {
+        i = 0;
+	att = atts[i++];
+	value = atts[i++];
+        while ((att != NULL) && (value != NULL)) {
+            if ((att[0] != 'x') || (att[1] != 'm') || (att[2] != 'l') ||
+                (att[3] != 'n') || (att[4] != 's'))
+                xmlSAX1Attribute(ctxt, att, value, NULL);
+
+            /*
+             * Next ones
+             */
+            att = atts[i++];
+            value = atts[i++];
+        }
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * If it's the Document root, finish the DTD validation and
+     * check the document root element for validity
+     */
+    if ((ctxt->validate) &&
+        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
+	int chk;
+
+	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+	if (chk <= 0)
+	    ctxt->valid = 0;
+	if (chk < 0)
+	    ctxt->wellFormed = 0;
+	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+	ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+
+    if (prefix != NULL)
+	xmlFree(prefix);
+
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+#ifdef LIBXML_HTML_ENABLED
+static void
+xmlSAX2HtmlAttribute(xmlParserCtxtPtr ctxt, const xmlChar *fullname,
+                     const xmlChar *value) {
+    xmlAttrPtr ret;
+    xmlChar *nval = NULL;
+
+    ret = xmlNewNsProp(ctxt->node, NULL, fullname, NULL);
+    if (ret == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    if ((value == NULL) && (htmlIsBooleanAttr(fullname))) {
+        nval = xmlStrdup(fullname);
+        if (nval == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+            return;
+        }
+        value = nval;
+    }
+
+    if (value != NULL) {
+        ret->children = xmlNewDocText(ctxt->myDoc, value);
+        if (ret->children == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+        } else {
+            ret->last = ret->children;
+            ret->children->parent = (xmlNodePtr) ret;
+        }
+    }
+
+    if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+        /*
+         * Don't create IDs containing entity references (should
+         * be always the case with HTML)
+         */
+        (ret->children != NULL) &&
+        (ret->children->type == XML_TEXT_NODE) &&
+        (ret->children->next == NULL)) {
+        int res = xmlIsID(ctxt->myDoc, ctxt->node, ret);
+
+        if (res < 0)
+            xmlCtxtErrMemory(ctxt);
+        else if (res > 0)
+            xmlAddID(&ctxt->vctxt, ctxt->myDoc, ret->children->content, ret);
+    }
+
+    if (nval != NULL)
+        xmlFree(nval);
+}
+
+/**
+ * Called when an opening tag has been processed.
+ *
+ * @param ctxt  parser context
+ * @param fullname  The element name, including namespace prefix
+ * @param atts  An array of name/value attributes pairs, NULL terminated
+ */
+static void
+xmlSAX2StartHtmlElement(xmlParserCtxtPtr ctxt, const xmlChar *fullname,
+                        const xmlChar **atts) {
+    xmlNodePtr ret;
+    xmlNodePtr parent;
+    const xmlChar *att;
+    const xmlChar *value;
+    int i;
+
+    ret = xmlNewDocNode(ctxt->myDoc, NULL, fullname, NULL);
+    if (ret == NULL) {
+	xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+    ctxt->nodemem = -1;
+
+    /* Initialize parent before pushing node */
+    parent = ctxt->node;
+    if (parent == NULL)
+        parent = (xmlNodePtr) ctxt->myDoc;
+
+    /*
+     * Link the child element
+     */
+    xmlSAX2AppendChild(ctxt, ret);
+
+    /*
+     * We are parsing a new node.
+     */
+    if (nodePush(ctxt, ret) < 0) {
+        xmlUnlinkNode(ret);
+        xmlFreeNode(ret);
+        return;
+    }
+
+    if (atts != NULL) {
+        i = 0;
+	att = atts[i++];
+	value = atts[i++];
+        while (att != NULL) {
+            xmlSAX2HtmlAttribute(ctxt, att, value);
+            att = atts[i++];
+            value = atts[i++];
+        }
+    }
+}
+#endif /* LIBXML_HTML_ENABLED */
+
+/**
+ * Called when an opening tag has been processed.
+ *
+ * @deprecated Don't call this function directly.
+ *
+ * Used for HTML and SAX1.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param fullname  The element name, including namespace prefix
+ * @param atts  An array of name/value attributes pairs, NULL terminated
+ */
+void
+xmlSAX2StartElement(void *ctx, const xmlChar *fullname, const xmlChar **atts) {
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+    (void) atts;
+
+    if ((ctxt == NULL) || (fullname == NULL) || (ctxt->myDoc == NULL))
+        return;
+
+#ifdef LIBXML_SAX1_ENABLED
+    if (!ctxt->html) {
+        xmlSAX1StartElement(ctxt, fullname, atts);
+        return;
+    }
+#endif
+
+#ifdef LIBXML_HTML_ENABLED
+    if (ctxt->html) {
+        xmlSAX2StartHtmlElement(ctxt, fullname, atts);
+        return;
+    }
+#endif
+}
+
+/**
+ * called when the end of an element has been detected.
+ *
+ * @deprecated Don't call this function directly.
+ *
+ * Used for HTML and SAX1.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The element name
+ */
+void
+xmlSAX2EndElement(void *ctx, const xmlChar *name ATTRIBUTE_UNUSED)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+    if (ctxt == NULL)
+        return;
+
+#if defined(LIBXML_SAX1_ENABLED) && defined(LIBXML_VALID_ENABLED)
+    if (!ctxt->html && ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
+					     ctxt->node);
+#endif /* LIBXML_VALID_ENABLED */
+
+#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED)
+    ctxt->nodemem = -1;
+
+    /*
+     * end of parsing of this node.
+     */
+    nodePop(ctxt);
+#endif
+}
+
+/*
+ * @param ctxt  the parser context
+ * @param doc  the document
+ * @param str  the input string
+ * @param len  the string length
+ *
+ * Callback for a text node
+ *
+ * @returns the newly allocated string or NULL if not needed or error
+ */
+static xmlNodePtr
+xmlSAX2TextNode(xmlParserCtxtPtr ctxt, xmlDocPtr doc, const xmlChar *str,
+                int len) {
+    xmlNodePtr ret;
+    const xmlChar *intern = NULL;
+
+    /*
+     * Allocate
+     */
+    if (ctxt->freeElems != NULL) {
+	ret = ctxt->freeElems;
+	ctxt->freeElems = ret->next;
+	ctxt->freeElemsNr--;
+    } else {
+	ret = (xmlNodePtr) xmlMalloc(sizeof(xmlNode));
+    }
+    if (ret == NULL) {
+        xmlCtxtErrMemory(ctxt);
+	return(NULL);
+    }
+    memset(ret, 0, sizeof(xmlNode));
+    /*
+     * intern the formatting blanks found between tags, or the
+     * very short strings
+     */
+    if ((!ctxt->html) && (ctxt->dictNames)) {
+        xmlChar cur = str[len];
+
+	if ((len < (int) (2 * sizeof(void *))) &&
+	    (ctxt->options & XML_PARSE_COMPACT)) {
+	    /* store the string in the node overriding properties and nsDef */
+	    xmlChar *tmp = (xmlChar *) &(ret->properties);
+	    memcpy(tmp, str, len);
+	    tmp[len] = 0;
+	    intern = tmp;
+	} else if ((len <= 3) && ((cur == '"') || (cur == '\'') ||
+	    ((cur == '<') && (str[len + 1] != '!')))) {
+	    intern = xmlDictLookup(ctxt->dict, str, len);
+            if (intern == NULL) {
+                xmlSAX2ErrMemory(ctxt);
+                xmlFree(ret);
+                return(NULL);
+            }
+	} else if (IS_BLANK_CH(*str) && (len < 60) && (cur == '<') &&
+	           (str[len + 1] != '!')) {
+	    int i;
+
+	    for (i = 1;i < len;i++) {
+		if (!IS_BLANK_CH(str[i])) goto skip;
+	    }
+	    intern = xmlDictLookup(ctxt->dict, str, len);
+            if (intern == NULL) {
+                xmlSAX2ErrMemory(ctxt);
+                xmlFree(ret);
+                return(NULL);
+            }
+	}
+    }
+skip:
+    ret->type = XML_TEXT_NODE;
+    ret->doc = doc;
+
+    ret->name = xmlStringText;
+    if (intern == NULL) {
+	ret->content = xmlStrndup(str, len);
+	if (ret->content == NULL) {
+	    xmlSAX2ErrMemory(ctxt);
+	    xmlFree(ret);
+	    return(NULL);
+	}
+    } else
+	ret->content = (xmlChar *) intern;
+
+    if ((xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	xmlRegisterNodeDefaultValue(ret);
+    return(ret);
+}
+
+#ifdef LIBXML_VALID_ENABLED
+/*
+ * @param ctxt  the parser context
+ * @param str  the input string
+ * @param len  the string length
+ *
+ * Remove the entities from an attribute value
+ *
+ * @returns the newly allocated string or NULL if not needed or error
+ */
+static xmlChar *
+xmlSAX2DecodeAttrEntities(xmlParserCtxtPtr ctxt, const xmlChar *str,
+                          const xmlChar *end) {
+    const xmlChar *in;
+
+    in = str;
+    while (in < end)
+        if (*in++ == '&')
+	    goto decode;
+    return(NULL);
+decode:
+    /*
+     * If the value contains '&', we can be sure it was allocated and is
+     * zero-terminated.
+     */
+    /* TODO: normalize if needed */
+    return(xmlExpandEntitiesInAttValue(ctxt, str, /* normalize */ 0));
+}
+#endif /* LIBXML_VALID_ENABLED */
+
+/**
+ * Handle an attribute that has been read by the parser.
+ * The default handling is to convert the attribute into an
+ * DOM subtree and past it in a new xmlAttr element added to
+ * the element.
+ *
+ * @param ctxt  the parser context
+ * @param localname  the local name of the attribute
+ * @param prefix  the attribute namespace prefix if available
+ * @param value  start of the attribute value
+ * @param valueend  end of the attribute value
+ * @returns the new attribute or NULL in case of error.
+ */
+static xmlAttrPtr
+xmlSAX2AttributeNs(xmlParserCtxtPtr ctxt,
+                   const xmlChar * localname,
+                   const xmlChar * prefix,
+		   const xmlChar * value,
+		   const xmlChar * valueend)
+{
+    xmlAttrPtr ret;
+    xmlNsPtr namespace = NULL;
+    xmlChar *dup = NULL;
+
+    /*
+     * Note: if prefix == NULL, the attribute is not in the default namespace
+     */
+    if (prefix != NULL) {
+	namespace = xmlParserNsLookupSax(ctxt, prefix);
+	if ((namespace == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
+            int res;
+
+	    res = xmlSearchNsSafe(ctxt->node, prefix, &namespace);
+            if (res < 0)
+                xmlSAX2ErrMemory(ctxt);
+	}
+    }
+
+    /*
+     * allocate the node
+     */
+    if (ctxt->freeAttrs != NULL) {
+        ret = ctxt->freeAttrs;
+	ctxt->freeAttrs = ret->next;
+	ctxt->freeAttrsNr--;
+    } else {
+        ret = xmlMalloc(sizeof(*ret));
+        if (ret == NULL) {
+            xmlSAX2ErrMemory(ctxt);
+            return(NULL);
+        }
+    }
+
+    memset(ret, 0, sizeof(xmlAttr));
+    ret->type = XML_ATTRIBUTE_NODE;
+
+    /*
+     * xmlParseBalancedChunkMemoryRecover had a bug that could result in
+     * a mismatch between ctxt->node->doc and ctxt->myDoc. We use
+     * ctxt->node->doc here, but we should somehow make sure that the
+     * document pointers match.
+     */
+
+    /* assert(ctxt->node->doc == ctxt->myDoc); */
+
+    ret->parent = ctxt->node;
+    ret->doc = ctxt->node->doc;
+    ret->ns = namespace;
+
+    if (ctxt->dictNames) {
+        ret->name = localname;
+    } else {
+        ret->name = xmlStrdup(localname);
+        if (ret->name == NULL)
+            xmlSAX2ErrMemory(ctxt);
+    }
+
+    if ((xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+        xmlRegisterNodeDefaultValue((xmlNodePtr)ret);
+
+    if ((ctxt->replaceEntities == 0) && (!ctxt->html)) {
+	xmlNodePtr tmp;
+
+	/*
+	 * We know that if there is an entity reference, then
+	 * the string has been dup'ed and terminates with 0
+	 * otherwise with ' or "
+	 */
+	if (*valueend != 0) {
+	    tmp = xmlSAX2TextNode(ctxt, ret->doc, value, valueend - value);
+	    ret->children = tmp;
+	    ret->last = tmp;
+	    if (tmp != NULL) {
+		tmp->parent = (xmlNodePtr) ret;
+	    }
+	} else if (valueend > value) {
+            if (xmlNodeParseAttValue(ret->doc, ret, value, valueend - value,
+                                     NULL) < 0)
+                xmlSAX2ErrMemory(ctxt);
+	}
+    } else if (value != NULL) {
+	xmlNodePtr tmp;
+
+	tmp = xmlSAX2TextNode(ctxt, ret->doc, value, valueend - value);
+	ret->children = tmp;
+	ret->last = tmp;
+	if (tmp != NULL) {
+	    tmp->parent = (xmlNodePtr) ret;
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset) {
+	/*
+	 * If we don't substitute entities, the validation should be
+	 * done on a value with replaced entities anyway.
+	 */
+        if (!ctxt->replaceEntities) {
+	    dup = xmlSAX2DecodeAttrEntities(ctxt, value, valueend);
+	    if (dup == NULL) {
+	        if (*valueend == 0) {
+		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				    ctxt->myDoc, ctxt->node, ret, value);
+		} else {
+		    /*
+		     * That should already be normalized.
+		     * cheaper to finally allocate here than duplicate
+		     * entry points in the full validation code
+		     */
+		    dup = xmlStrndup(value, valueend - value);
+                    if (dup == NULL)
+                        xmlSAX2ErrMemory(ctxt);
+
+		    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+				    ctxt->myDoc, ctxt->node, ret, dup);
+		}
+	    } else {
+	        /*
+		 * dup now contains a string of the flattened attribute
+		 * content with entities substituted. Check if we need to
+		 * apply an extra layer of normalization.
+		 * It need to be done twice ... it's an extra burden related
+		 * to the ability to keep references in attributes
+		 */
+		if (ctxt->attsSpecial != NULL) {
+		    xmlChar *nvalnorm;
+		    xmlChar fn[50];
+		    xmlChar *fullname;
+
+		    fullname = xmlBuildQName(localname, prefix, fn, 50);
+                    if (fullname == NULL) {
+                        xmlSAX2ErrMemory(ctxt);
+                    } else {
+			ctxt->vctxt.valid = 1;
+		        nvalnorm = xmlValidCtxtNormalizeAttributeValue(
+			                 &ctxt->vctxt, ctxt->myDoc,
+					 ctxt->node, fullname, dup);
+			if (ctxt->vctxt.valid != 1)
+			    ctxt->valid = 0;
+
+			if ((fullname != fn) && (fullname != localname))
+			    xmlFree(fullname);
+			if (nvalnorm != NULL) {
+			    xmlFree(dup);
+			    dup = nvalnorm;
+			}
+		    }
+		}
+
+		ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+			        ctxt->myDoc, ctxt->node, ret, dup);
+	    }
+	} else {
+	    /*
+	     * if entities already have been substituted, then
+	     * the attribute as passed is already normalized
+	     */
+	    dup = xmlStrndup(value, valueend - value);
+            if (dup == NULL)
+                xmlSAX2ErrMemory(ctxt);
+
+            /*
+             * When replacing entities, make sure that IDs in
+             * entities aren't registered. This also shouldn't be
+             * done when entities aren't replaced, but this would
+             * require to rework IDREF checks.
+             */
+            if (ctxt->input->entity != NULL)
+                ctxt->vctxt.flags |= XML_VCTXT_IN_ENTITY;
+
+	    ctxt->valid &= xmlValidateOneAttribute(&ctxt->vctxt,
+	                             ctxt->myDoc, ctxt->node, ret, dup);
+
+            ctxt->vctxt.flags &= ~XML_VCTXT_IN_ENTITY;
+	}
+    } else
+#endif /* LIBXML_VALID_ENABLED */
+           if (((ctxt->loadsubset & XML_SKIP_IDS) == 0) &&
+               (ctxt->input->entity == NULL) &&
+               /* Don't create IDs containing entity references */
+               (ret->children != NULL) &&
+               (ret->children->type == XML_TEXT_NODE) &&
+               (ret->children->next == NULL)) {
+        xmlChar *content = ret->children->content;
+        /*
+	 * when validating, the ID registration is done at the attribute
+	 * validation level. Otherwise we have to do specific handling here.
+	 */
+        if ((prefix == ctxt->str_xml) &&
+	           (localname[0] == 'i') && (localname[1] == 'd') &&
+		   (localname[2] == 0)) {
+	    /*
+	     * Add the xml:id value
+	     *
+	     * Open issue: normalization of the value.
+	     */
+	    if (xmlValidateNCName(content, 1) != 0) {
+	        xmlErrId(ctxt, XML_DTD_XMLID_VALUE,
+                         "xml:id : attribute value %s is not an NCName\n",
+                         content);
+	    }
+	    xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
+	} else {
+            int res = xmlIsID(ctxt->myDoc, ctxt->node, ret);
+
+            if (res < 0)
+                xmlCtxtErrMemory(ctxt);
+            else if (res > 0)
+                xmlAddID(&ctxt->vctxt, ctxt->myDoc, content, ret);
+            else if (xmlIsRef(ctxt->myDoc, ctxt->node, ret))
+                xmlAddRef(&ctxt->vctxt, ctxt->myDoc, content, ret);
+	}
+    }
+    if (dup != NULL)
+	xmlFree(dup);
+
+    return(ret);
+}
+
+/**
+ * SAX2 callback when an element start has been detected by the parser.
+ * It provides the namespace information for the element, as well as
+ * the new namespace declarations on the element.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param localname  the local name of the element
+ * @param prefix  the element namespace prefix if available
+ * @param URI  the element namespace name if available
+ * @param nb_namespaces  number of namespace definitions on that node
+ * @param namespaces  pointer to the array of prefix/URI pairs namespace definitions
+ * @param nb_attributes  the number of attributes on that node
+ * @param nb_defaulted  the number of defaulted attributes.
+ * @param attributes  pointer to the array of (localname/prefix/URI/value/end)
+ *               attribute values.
+ */
+void
+xmlSAX2StartElementNs(void *ctx,
+                      const xmlChar *localname,
+		      const xmlChar *prefix,
+		      const xmlChar *URI,
+		      int nb_namespaces,
+		      const xmlChar **namespaces,
+		      int nb_attributes,
+		      int nb_defaulted,
+		      const xmlChar **attributes)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+    xmlNsPtr last = NULL, ns;
+    const xmlChar *uri, *pref;
+    xmlChar *lname = NULL;
+    int i, j;
+
+    if (ctx == NULL) return;
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * First check on validity:
+     */
+    if (ctxt->validate &&
+        ((ctxt->myDoc == NULL) ||
+         ((ctxt->myDoc->extSubset == NULL) &&
+          ((ctxt->myDoc->intSubset == NULL) ||
+	   ((ctxt->myDoc->intSubset->notations == NULL) &&
+	    (ctxt->myDoc->intSubset->elements == NULL) &&
+	    (ctxt->myDoc->intSubset->attributes == NULL) &&
+	    (ctxt->myDoc->intSubset->entities == NULL)))))) {
+	xmlErrValid(ctxt, XML_DTD_NO_DTD,
+	  "Validation failed: no DTD found !", NULL, NULL);
+	ctxt->validate = 0;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * Take care of the rare case of an undefined namespace prefix
+     */
+    if ((prefix != NULL) && (URI == NULL)) {
+        if (ctxt->dictNames) {
+	    const xmlChar *fullname;
+
+	    fullname = xmlDictQLookup(ctxt->dict, prefix, localname);
+	    if (fullname == NULL) {
+                xmlSAX2ErrMemory(ctxt);
+                return;
+            }
+	    localname = fullname;
+	} else {
+	    lname = xmlBuildQName(localname, prefix, NULL, 0);
+            if (lname == NULL) {
+                xmlSAX2ErrMemory(ctxt);
+                return;
+            }
+	}
+    }
+    /*
+     * allocate the node
+     */
+    if (ctxt->freeElems != NULL) {
+        ret = ctxt->freeElems;
+	ctxt->freeElems = ret->next;
+	ctxt->freeElemsNr--;
+	memset(ret, 0, sizeof(xmlNode));
+        ret->doc = ctxt->myDoc;
+	ret->type = XML_ELEMENT_NODE;
+
+	if (ctxt->dictNames)
+	    ret->name = localname;
+	else {
+	    if (lname == NULL)
+		ret->name = xmlStrdup(localname);
+	    else
+	        ret->name = lname;
+	    if (ret->name == NULL) {
+	        xmlSAX2ErrMemory(ctxt);
+                xmlFree(ret);
+		return;
+	    }
+	}
+	if ((xmlRegisterCallbacks) && (xmlRegisterNodeDefaultValue))
+	    xmlRegisterNodeDefaultValue(ret);
+    } else {
+	if (ctxt->dictNames)
+	    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL,
+	                               (xmlChar *) localname, NULL);
+	else if (lname == NULL)
+	    ret = xmlNewDocNode(ctxt->myDoc, NULL, localname, NULL);
+	else
+	    ret = xmlNewDocNodeEatName(ctxt->myDoc, NULL, lname, NULL);
+	if (ret == NULL) {
+	    xmlSAX2ErrMemory(ctxt);
+	    return;
+	}
+    }
+
+    /*
+     * Build the namespace list
+     */
+    for (i = 0,j = 0;j < nb_namespaces;j++) {
+        pref = namespaces[i++];
+	uri = namespaces[i++];
+	ns = xmlNewNs(NULL, uri, pref);
+	if (ns != NULL) {
+	    if (last == NULL) {
+	        ret->nsDef = last = ns;
+	    } else {
+	        last->next = ns;
+		last = ns;
+	    }
+	    if ((URI != NULL) && (prefix == pref))
+		ret->ns = ns;
+	} else {
+            xmlSAX2ErrMemory(ctxt);
+	    continue;
+	}
+
+        xmlParserNsUpdateSax(ctxt, pref, ns);
+
+#ifdef LIBXML_VALID_ENABLED
+	if ((!ctxt->html) && ctxt->validate && ctxt->wellFormed &&
+	    ctxt->myDoc && ctxt->myDoc->intSubset) {
+	    ctxt->valid &= xmlValidateOneNamespace(&ctxt->vctxt, ctxt->myDoc,
+	                                           ret, prefix, ns, uri);
+	}
+#endif /* LIBXML_VALID_ENABLED */
+    }
+    ctxt->nodemem = -1;
+
+    /*
+     * Link the child element
+     */
+    xmlSAX2AppendChild(ctxt, ret);
+
+    /*
+     * We are parsing a new node.
+     */
+    if (nodePush(ctxt, ret) < 0) {
+        xmlUnlinkNode(ret);
+        xmlFreeNode(ret);
+        return;
+    }
+
+    /*
+     * Insert the defaulted attributes from the DTD only if requested:
+     */
+    if ((nb_defaulted != 0) &&
+        ((ctxt->loadsubset & XML_COMPLETE_ATTRS) == 0))
+	nb_attributes -= nb_defaulted;
+
+    /*
+     * Search the namespace if it wasn't already found
+     * Note that, if prefix is NULL, this searches for the default Ns
+     */
+    if ((URI != NULL) && (ret->ns == NULL)) {
+        ret->ns = xmlParserNsLookupSax(ctxt, prefix);
+	if ((ret->ns == NULL) && (xmlStrEqual(prefix, BAD_CAST "xml"))) {
+            int res;
+
+	    res = xmlSearchNsSafe(ret, prefix, &ret->ns);
+            if (res < 0)
+                xmlSAX2ErrMemory(ctxt);
+	}
+	if (ret->ns == NULL) {
+	    ns = xmlNewNs(ret, NULL, prefix);
+	    if (ns == NULL) {
+
+	        xmlSAX2ErrMemory(ctxt);
+		return;
+	    }
+            if (prefix != NULL)
+                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+                             "Namespace prefix %s was not found\n",
+                             prefix, NULL);
+            else
+                xmlNsWarnMsg(ctxt, XML_NS_ERR_UNDEFINED_NAMESPACE,
+                             "Namespace default prefix was not found\n",
+                             NULL, NULL);
+	}
+    }
+
+    /*
+     * process all the other attributes
+     */
+    if (nb_attributes > 0) {
+        xmlAttrPtr prev = NULL;
+
+        for (j = 0,i = 0;i < nb_attributes;i++,j+=5) {
+            xmlAttrPtr attr = NULL;
+
+	    /*
+	     * Handle the rare case of an undefined attribute prefix
+	     */
+	    if ((attributes[j+1] != NULL) && (attributes[j+2] == NULL)) {
+		if (ctxt->dictNames) {
+		    const xmlChar *fullname;
+
+		    fullname = xmlDictQLookup(ctxt->dict, attributes[j+1],
+		                              attributes[j]);
+		    if (fullname == NULL) {
+                        xmlSAX2ErrMemory(ctxt);
+                        return;
+                    }
+                    attr = xmlSAX2AttributeNs(ctxt, fullname, NULL,
+                                              attributes[j+3],
+                                              attributes[j+4]);
+                    goto have_attr;
+		} else {
+		    lname = xmlBuildQName(attributes[j], attributes[j+1],
+		                          NULL, 0);
+		    if (lname == NULL) {
+                        xmlSAX2ErrMemory(ctxt);
+                        return;
+                    }
+                    attr = xmlSAX2AttributeNs(ctxt, lname, NULL,
+                                              attributes[j+3],
+                                              attributes[j+4]);
+                    xmlFree(lname);
+                    goto have_attr;
+		}
+	    }
+            attr = xmlSAX2AttributeNs(ctxt, attributes[j], attributes[j+1],
+                                      attributes[j+3], attributes[j+4]);
+have_attr:
+            if (attr == NULL)
+                continue;
+
+            /* link at the end to preserve order */
+            if (prev == NULL) {
+                ctxt->node->properties = attr;
+            } else {
+                prev->next = attr;
+                attr->prev = prev;
+            }
+
+            prev = attr;
+	}
+    }
+
+#ifdef LIBXML_VALID_ENABLED
+    /*
+     * If it's the Document root, finish the DTD validation and
+     * check the document root element for validity
+     */
+    if ((ctxt->validate) &&
+        ((ctxt->vctxt.flags & XML_VCTXT_DTD_VALIDATED) == 0)) {
+	int chk;
+
+	chk = xmlValidateDtdFinal(&ctxt->vctxt, ctxt->myDoc);
+	if (chk <= 0)
+	    ctxt->valid = 0;
+	if (chk < 0)
+	    ctxt->wellFormed = 0;
+	ctxt->valid &= xmlValidateRoot(&ctxt->vctxt, ctxt->myDoc);
+	ctxt->vctxt.flags |= XML_VCTXT_DTD_VALIDATED;
+    }
+#endif /* LIBXML_VALID_ENABLED */
+}
+
+/**
+ * SAX2 callback when an element end has been detected by the parser.
+ * It provides the namespace information for the element.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param localname  the local name of the element
+ * @param prefix  the element namespace prefix if available
+ * @param URI  the element namespace name if available
+ */
+void
+xmlSAX2EndElementNs(void *ctx,
+                    const xmlChar * localname ATTRIBUTE_UNUSED,
+                    const xmlChar * prefix ATTRIBUTE_UNUSED,
+		    const xmlChar * URI ATTRIBUTE_UNUSED)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+
+    if (ctx == NULL) return;
+    ctxt->nodemem = -1;
+
+#ifdef LIBXML_VALID_ENABLED
+    if (ctxt->validate && ctxt->wellFormed &&
+        ctxt->myDoc && ctxt->myDoc->intSubset)
+        ctxt->valid &= xmlValidateOneElement(&ctxt->vctxt, ctxt->myDoc,
+                                             ctxt->node);
+#endif /* LIBXML_VALID_ENABLED */
+
+    /*
+     * end of parsing of this node.
+     */
+    nodePop(ctxt);
+}
+
+/**
+ * called when an entity #xmlSAX2Reference is detected.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param name  The entity name
+ */
+void
+xmlSAX2Reference(void *ctx, const xmlChar *name)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+
+    if (ctx == NULL) return;
+    ret = xmlNewReference(ctxt->myDoc, name);
+    if (ret == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    xmlSAX2AppendChild(ctxt, ret);
+}
+
+/**
+ * Append characters.
+ *
+ * @param ctxt  the parser context
+ * @param ch  a xmlChar string
+ * @param len  the number of xmlChar
+ * @param type  text or cdata
+ */
+static void
+xmlSAX2Text(xmlParserCtxtPtr ctxt, const xmlChar *ch, int len,
+            xmlElementType type)
+{
+    xmlNodePtr lastChild;
+    xmlNodePtr parent;
+
+    if (ctxt == NULL)
+        return;
+
+    parent = ctxt->node;
+    if (parent == NULL)
+        return;
+    lastChild = parent->last;
+
+    /*
+     * Try to merge with previous text node using size and capacity
+     * stored in the parser context to avoid naive concatenation.
+     *
+     * Don't merge CDATA sections. In HTML mode, CDATA is used for
+     * raw text which should be merged.
+     */
+    if ((lastChild == NULL) ||
+        (lastChild->type != type) ||
+        ((!ctxt->html) && (type != XML_TEXT_NODE))) {
+        xmlNode *node;
+
+        if (type == XML_TEXT_NODE)
+            node = xmlSAX2TextNode(ctxt, parent->doc, ch, len);
+        else
+            node = xmlNewCDataBlock(parent->doc, ch, len);
+	if (node == NULL) {
+	    xmlSAX2ErrMemory(ctxt);
+	    return;
+	}
+
+        if (lastChild == NULL) {
+            parent->children = node;
+            parent->last = node;
+            node->parent = parent;
+        } else {
+            xmlSAX2AppendChild(ctxt, node);
+        }
+
+        ctxt->nodelen = len;
+        ctxt->nodemem = len + 1;
+        lastChild = node;
+    } else {
+        xmlChar *content;
+        int oldSize, newSize, capacity;
+        int maxSize = (ctxt->options & XML_PARSE_HUGE) ?
+                      XML_MAX_HUGE_LENGTH :
+                      XML_MAX_TEXT_LENGTH;
+
+        content = lastChild->content;
+        oldSize = ctxt->nodelen;
+        capacity = ctxt->nodemem;
+
+        /* Shouldn't happen */
+        if ((content == NULL) || (capacity <= 0)) {
+            xmlFatalErr(ctxt, XML_ERR_INTERNAL_ERROR,
+                        "xmlSAX2Text: no content");
+            return;
+        }
+
+        if ((len > maxSize) || (oldSize > maxSize - len)) {
+            xmlFatalErr(ctxt, XML_ERR_RESOURCE_LIMIT,
+                        "Text node too long, try XML_PARSE_HUGE");
+            return;
+        }
+
+        newSize = oldSize + len;
+
+        if (newSize >= capacity) {
+            if (newSize <= 20)
+                capacity = 40;
+            else
+                capacity = newSize > INT_MAX / 2 ? INT_MAX : newSize * 2;
+
+            /*
+             * If the content was stored in properties or in
+             * the dictionary, don't realloc.
+             */
+            if ((content == (xmlChar *) &lastChild->properties) ||
+                ((ctxt->nodemem == oldSize + 1) &&
+                 (xmlDictOwns(ctxt->dict, content)))) {
+                xmlChar *newContent;
+
+                newContent = xmlMalloc(capacity);
+                if (newContent == NULL) {
+                    xmlSAX2ErrMemory(ctxt);
+                    return;
+                }
+
+                memcpy(newContent, content, oldSize);
+                lastChild->properties = NULL;
+                content = newContent;
+            } else {
+                content = xmlRealloc(content, capacity);
+                if (content == NULL) {
+                    xmlSAX2ErrMemory(ctxt);
+                    return;
+                }
+            }
+
+            ctxt->nodemem = capacity;
+            lastChild->content = content;
+        }
+
+        memcpy(&content[oldSize], ch, len);
+        content[newSize] = 0;
+        ctxt->nodelen = newSize;
+    }
+
+    if ((lastChild != NULL) &&
+        (type == XML_TEXT_NODE) &&
+        (ctxt->input != NULL)) {
+        if ((unsigned) ctxt->input->line < (unsigned) USHRT_MAX)
+            lastChild->line = ctxt->input->line;
+        else {
+            lastChild->line = USHRT_MAX;
+            if (ctxt->options & XML_PARSE_BIG_LINES)
+                lastChild->psvi = XML_INT_TO_PTR(ctxt->input->line);
+        }
+    }
+}
+
+/**
+ * receiving some chars from the parser.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param ch  a xmlChar string
+ * @param len  the number of xmlChar
+ */
+void
+xmlSAX2Characters(void *ctx, const xmlChar *ch, int len)
+{
+    xmlSAX2Text((xmlParserCtxtPtr) ctx, ch, len, XML_TEXT_NODE);
+}
+
+/**
+ * receiving some ignorable whitespaces from the parser.
+ * UNUSED: by default the DOM building will use #xmlSAX2Characters
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param ch  a xmlChar string
+ * @param len  the number of xmlChar
+ */
+void
+xmlSAX2IgnorableWhitespace(void *ctx ATTRIBUTE_UNUSED, const xmlChar *ch ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
+{
+}
+
+/**
+ * A processing instruction has been parsed.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param target  the target name
+ * @param data  the PI data's
+ */
+void
+xmlSAX2ProcessingInstruction(void *ctx, const xmlChar *target,
+                      const xmlChar *data)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+
+    if (ctx == NULL) return;
+
+    ret = xmlNewDocPI(ctxt->myDoc, target, data);
+    if (ret == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    xmlSAX2AppendChild(ctxt, ret);
+}
+
+/**
+ * A #xmlSAX2Comment has been parsed.
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param value  the #xmlSAX2Comment content
+ */
+void
+xmlSAX2Comment(void *ctx, const xmlChar *value)
+{
+    xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr) ctx;
+    xmlNodePtr ret;
+
+    if (ctx == NULL) return;
+
+    ret = xmlNewDocComment(ctxt->myDoc, value);
+    if (ret == NULL) {
+        xmlSAX2ErrMemory(ctxt);
+        return;
+    }
+
+    xmlSAX2AppendChild(ctxt, ret);
+}
+
+/**
+ * called when a pcdata block has been parsed
+ *
+ * @param ctx  the user data (XML parser context)
+ * @param value  The pcdata content
+ * @param len  the block length
+ */
+void
+xmlSAX2CDataBlock(void *ctx, const xmlChar *value, int len)
+{
+    xmlSAX2Text((xmlParserCtxtPtr) ctx, value, len, XML_CDATA_SECTION_NODE);
+}
+
+#ifdef LIBXML_SAX1_ENABLED
+/**
+ * Has no effect.
+ *
+ * @deprecated Use parser option XML_PARSE_SAX1.
+ *
+ * @param version  the version, must be 2
+ * @returns 2 in case of success and -1 in case of error.
+ */
+int
+xmlSAXDefaultVersion(int version)
+{
+    if (version != 2)
+        return(-1);
+    return(2);
+}
+#endif /* LIBXML_SAX1_ENABLED */
+
+/**
+ * Initialize the default XML SAX handler according to the version
+ *
+ * @param hdlr  the SAX handler
+ * @param version  the version, 1 or 2
+ * @returns 0 in case of success and -1 in case of error.
+ */
+int
+xmlSAXVersion(xmlSAXHandler *hdlr, int version)
+{
+    if (hdlr == NULL) return(-1);
+    if (version == 2) {
+	hdlr->startElementNs = xmlSAX2StartElementNs;
+	hdlr->endElementNs = xmlSAX2EndElementNs;
+	hdlr->serror = NULL;
+	hdlr->initialized = XML_SAX2_MAGIC;
+#ifdef LIBXML_SAX1_ENABLED
+    } else if (version == 1) {
+	hdlr->initialized = 1;
+#endif /* LIBXML_SAX1_ENABLED */
+    } else
+        return(-1);
+#ifdef LIBXML_SAX1_ENABLED
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+#else
+    hdlr->startElement = NULL;
+    hdlr->endElement = NULL;
+#endif /* LIBXML_SAX1_ENABLED */
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = xmlSAX2ExternalSubset;
+    hdlr->isStandalone = xmlSAX2IsStandalone;
+    hdlr->hasInternalSubset = xmlSAX2HasInternalSubset;
+    hdlr->hasExternalSubset = xmlSAX2HasExternalSubset;
+    hdlr->resolveEntity = xmlSAX2ResolveEntity;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = xmlSAX2GetParameterEntity;
+    hdlr->entityDecl = xmlSAX2EntityDecl;
+    hdlr->attributeDecl = xmlSAX2AttributeDecl;
+    hdlr->elementDecl = xmlSAX2ElementDecl;
+    hdlr->notationDecl = xmlSAX2NotationDecl;
+    hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->reference = xmlSAX2Reference;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2Characters;
+    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    return(0);
+}
+
+/**
+ * Initialize the default XML SAX2 handler
+ *
+ * @param hdlr  the SAX handler
+ * @param warning  flag if non-zero sets the handler warning procedure
+ */
+void
+xmlSAX2InitDefaultSAXHandler(xmlSAXHandler *hdlr, int warning)
+{
+    if ((hdlr == NULL) || (hdlr->initialized != 0))
+	return;
+
+    xmlSAXVersion(hdlr, 2);
+    if (warning == 0)
+	hdlr->warning = NULL;
+}
+
+/**
+ * Initialize the default SAX2 handler
+ *
+ * @deprecated This function is a no-op. Call #xmlInitParser to
+ * initialize the library.
+ *
+ */
+void
+xmlDefaultSAXHandlerInit(void)
+{
+}
+
+#ifdef LIBXML_HTML_ENABLED
+
+/**
+ * Initialize the default HTML SAX2 handler
+ *
+ * @param hdlr  the SAX handler
+ */
+void
+xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr)
+{
+    if ((hdlr == NULL) || (hdlr->initialized != 0))
+	return;
+
+    hdlr->internalSubset = xmlSAX2InternalSubset;
+    hdlr->externalSubset = NULL;
+    hdlr->isStandalone = NULL;
+    hdlr->hasInternalSubset = NULL;
+    hdlr->hasExternalSubset = NULL;
+    hdlr->resolveEntity = NULL;
+    hdlr->getEntity = xmlSAX2GetEntity;
+    hdlr->getParameterEntity = NULL;
+    hdlr->entityDecl = NULL;
+    hdlr->attributeDecl = NULL;
+    hdlr->elementDecl = NULL;
+    hdlr->notationDecl = NULL;
+    hdlr->unparsedEntityDecl = NULL;
+    hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator;
+    hdlr->startDocument = xmlSAX2StartDocument;
+    hdlr->endDocument = xmlSAX2EndDocument;
+    hdlr->startElement = xmlSAX2StartElement;
+    hdlr->endElement = xmlSAX2EndElement;
+    hdlr->reference = NULL;
+    hdlr->characters = xmlSAX2Characters;
+    hdlr->cdataBlock = xmlSAX2CDataBlock;
+    hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace;
+    hdlr->processingInstruction = xmlSAX2ProcessingInstruction;
+    hdlr->comment = xmlSAX2Comment;
+    hdlr->warning = xmlParserWarning;
+    hdlr->error = xmlParserError;
+    hdlr->fatalError = xmlParserError;
+
+    hdlr->initialized = 1;
+}
+
+/**
+ * @deprecated This function is a no-op. Call #xmlInitParser to
+ * initialize the library.
+ */
+void
+htmlDefaultSAXHandlerInit(void)
+{
+}
+
+#endif /* LIBXML_HTML_ENABLED */

VERSION

@@ -0,0 +1 @@
+2.16.0

autogen.sh

@@ -0,0 +1,97 @@
+#!/bin/sh
+# Run this to generate all the initial makefiles, etc.
+
+THEDIR=`pwd`
+cd `dirname $0`
+srcdir=`pwd`
+
+DIE=0
+
+(autoconf --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	echo "You must have autoconf installed to compile libxml."
+	echo "Download the appropriate package for your distribution,"
+	echo "or see http://www.gnu.org/software/autoconf"
+	DIE=1
+}
+
+(libtoolize --version) < /dev/null > /dev/null 2>&1 ||
+(glibtoolize --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	echo "You must have libtool installed to compile libxml."
+	echo "Download the appropriate package for your distribution,"
+	echo "or see http://www.gnu.org/software/libtool"
+	DIE=1
+}
+
+(automake --version) < /dev/null > /dev/null 2>&1 || {
+	echo
+	DIE=1
+	echo "You must have automake installed to compile libxml."
+	echo "Download the appropriate package for your distribution,"
+	echo "or see http://www.gnu.org/software/automake"
+}
+
+if test "$DIE" -eq 1; then
+	exit 1
+fi
+
+test -f entities.c || {
+	echo "You must run this script in the top-level libxml directory"
+	exit 1
+}
+
+EXTRA_ARGS=
+if test "x$1" = "x--system"; then
+    shift
+    prefix=/usr
+    libdir=$prefix/lib
+    sysconfdir=/etc
+    localstatedir=/var
+    if [ -d /usr/lib64 ]; then
+      libdir=$prefix/lib64
+    fi
+    EXTRA_ARGS="--prefix=$prefix --sysconfdir=$sysconfdir --localstatedir=$localstatedir --libdir=$libdir"
+    echo "Running ./configure with $EXTRA_ARGS $@"
+else
+    if test -z "$NOCONFIGURE" && test -z "$*"; then
+        echo "I am going to run ./configure with no arguments - if you wish "
+        echo "to pass any to it, please specify them on the $0 command line."
+    fi
+fi
+
+if [ ! -d $srcdir/m4 ]; then
+        mkdir $srcdir/m4
+fi
+
+aclocal
+
+if ! grep -q pkg.m4 aclocal.m4; then
+    cat <<EOF
+
+Couldn't find pkg.m4 from pkg-config. Install the appropriate package for
+your distribution or set ACLOCAL_PATH to the directory containing pkg.m4.
+EOF
+    exit 1
+fi
+
+autoreconf -if -Wall || exit 1
+
+cd $THEDIR
+
+if test x$OBJ_DIR != x; then
+    mkdir -p "$OBJ_DIR"
+    cd "$OBJ_DIR"
+fi
+
+if test -z "$NOCONFIGURE"; then
+    $srcdir/configure $EXTRA_ARGS "$@"
+    if test "$?" -ne 0; then
+        echo
+        echo "Configure script failed, check config.log for more info."
+        exit 1
+    else
+        echo
+        echo "Now type 'make' to compile libxml2."
+    fi
+fi

buf.c

@@ -0,0 +1,1156 @@
+/*
+ * buf.c: memory buffers for libxml2
+ *
+ * new buffer structures and entry points to simplify the maintenance
+ * of libxml2 and ensure we keep good control over memory allocations
+ * and stay 64 bits clean.
+ * The new entry point use the xmlBuf opaque structure and
+ * xmlBuf...() counterparts to the old xmlBuf...() functions
+ *
+ * See Copyright for the status of this software.
+ *
+ * Author: Daniel Veillard
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+
+#include <string.h>
+#include <limits.h>
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include "private/buf.h"
+
+#ifndef SIZE_MAX
+#define SIZE_MAX ((size_t) -1)
+#endif
+
+#define BUF_FLAG_OOM        (1u << 0)
+#define BUF_FLAG_OVERFLOW   (1u << 1)
+#define BUF_FLAG_STATIC     (1u << 2)
+
+#define BUF_ERROR(buf) ((buf)->flags & (BUF_FLAG_OOM | BUF_FLAG_OVERFLOW))
+#define BUF_STATIC(buf) ((buf)->flags & BUF_FLAG_STATIC)
+
+/**
+ * A buffer structure. The base of the structure is somehow compatible
+ * with struct _xmlBuffer to limit risks on application which accessed
+ * directly the input->buf->buffer structures.
+ */
+
+struct _xmlBuf {
+    xmlChar *content;		/* The buffer content UTF8 */
+    xmlChar *mem;		/* Start of the allocation */
+    size_t use;		        /* The buffer size used */
+    size_t size;		/* The buffer size, excluding terminating 0 */
+    size_t maxSize;             /* The maximum buffer size */
+    unsigned flags;             /* flags */
+};
+
+/**
+ * Handle an out of memory condition
+ * To be improved...
+ *
+ * @param buf  the buffer
+ */
+static void
+xmlBufMemoryError(xmlBufPtr buf)
+{
+    if (!BUF_ERROR(buf))
+        buf->flags |= BUF_FLAG_OOM;
+}
+
+/**
+ * Handle a buffer overflow error
+ * To be improved...
+ *
+ * @param buf  the buffer
+ */
+static void
+xmlBufOverflowError(xmlBufPtr buf)
+{
+    if (!BUF_ERROR(buf))
+        buf->flags |= BUF_FLAG_OVERFLOW;
+}
+
+/**
+ * Create a buffer.
+ *
+ * @param size  initial buffer size
+ * @returns  the new structure
+ */
+xmlBuf *
+xmlBufCreate(size_t size) {
+    xmlBufPtr ret;
+
+    if (size == SIZE_MAX)
+        return(NULL);
+
+    ret = xmlMalloc(sizeof(*ret));
+    if (ret == NULL)
+        return(NULL);
+
+    ret->use = 0;
+    ret->flags = 0;
+    ret->size = size;
+    ret->maxSize = SIZE_MAX - 1;
+
+    ret->mem = xmlMalloc(ret->size + 1);
+    if (ret->mem == NULL) {
+        xmlFree(ret);
+        return(NULL);
+    }
+    ret->content = ret->mem;
+    ret->content[0] = 0;
+
+    return(ret);
+}
+
+/**
+ * Create a buffer initialized with memory.
+ *
+ * If `isStatic` is set, uses the memory area directly as backing store.
+ * The memory must be zero-terminated and not be modified for the
+ * lifetime of the buffer. A static buffer can't be grown, modified or
+ * detached, but it can be shrunk.
+ *
+ * @param mem  a memory area
+ * @param size  size of the buffer excluding terminator
+ * @param isStatic  whether the memory area is static
+ * @returns  a new buffer.
+ */
+xmlBuf *
+xmlBufCreateMem(const xmlChar *mem, size_t size, int isStatic) {
+    xmlBufPtr ret;
+
+    if (mem == NULL)
+        return(NULL);
+
+    ret = xmlMalloc(sizeof(*ret));
+    if (ret == NULL)
+        return(NULL);
+
+    if (isStatic) {
+        /* Check that memory is zero-terminated */
+        if (mem[size] != 0) {
+            xmlFree(ret);
+            return(NULL);
+        }
+        ret->flags = BUF_FLAG_STATIC;
+        ret->mem = (xmlChar *) mem;
+    } else {
+        ret->flags = 0;
+        ret->mem = xmlMalloc(size + 1);
+        if (ret->mem == NULL) {
+            xmlFree(ret);
+            return(NULL);
+        }
+        memcpy(ret->mem, mem, size);
+        ret->mem[size] = 0;
+    }
+
+    ret->use = size;
+    ret->size = size;
+    ret->maxSize = SIZE_MAX - 1;
+    ret->content = ret->mem;
+
+    return(ret);
+}
+
+/**
+ * Extract buffer content.
+ *
+ * Return the content of the buffer as an `xmlChar` string,
+ * clearing the buffer.
+ *
+ * This doesn't work with static buffers as they can't be reset.
+ *
+ * @param buf  the buffer
+ * @returns  the buffer content
+ */
+xmlChar *
+xmlBufDetach(xmlBuf *buf) {
+    xmlChar *ret;
+
+    if ((buf == NULL) || (BUF_ERROR(buf)) || (BUF_STATIC(buf)))
+        return(NULL);
+
+    if (buf->content != buf->mem) {
+        ret = xmlStrndup(buf->content, buf->use);
+        xmlFree(buf->mem);
+    } else {
+        ret = buf->mem;
+    }
+
+    buf->content = NULL;
+    buf->mem = NULL;
+    buf->size = 0;
+    buf->use = 0;
+
+    return ret;
+}
+
+/**
+ * Free a buffer.
+ *
+ * @param buf  the buffer to free
+ */
+void
+xmlBufFree(xmlBuf *buf) {
+    if (buf == NULL)
+	return;
+
+    if (!BUF_STATIC(buf))
+        xmlFree(buf->mem);
+    xmlFree(buf);
+}
+
+/**
+ * Empty a buffer.
+ *
+ * @param buf  the buffer
+ */
+void
+xmlBufEmpty(xmlBuf *buf) {
+    if ((buf == NULL) || (BUF_ERROR(buf)) || (BUF_STATIC(buf)))
+        return;
+    if (buf->mem == NULL)
+        return;
+
+    buf->use = 0;
+    buf->size += buf->content - buf->mem;
+    buf->content = buf->mem;
+    buf->content[0] = 0;
+}
+
+/**
+ * Discard bytes at the start of a buffer.
+ *
+ * NOTE that the return value differs from #xmlBufferShrink
+ * as it will return 0 on error instead of -1 due to size_t being
+ * used as the return type.
+ *
+ * @deprecated Internal function, don't use.
+ *
+ * @param buf  the buffer
+ * @param len  the number of bytes to remove
+ * @returns  the number of bytes removed or 0 in case of failure
+ */
+size_t
+xmlBufShrink(xmlBuf *buf, size_t len) {
+    if ((buf == NULL) || (BUF_ERROR(buf)))
+        return(0);
+    if (len == 0)
+        return(0);
+
+    if (len > buf->use)
+        return(0);
+
+    buf->use -= len;
+    buf->content += len;
+    buf->size -= len;
+
+    return(len);
+}
+
+/**
+ * Grow a buffer.
+ *
+ * Increase the capacity of a buffer. `len` is the amount of
+ * free space required after the current end of the buffer.
+ *
+ * Assumes `len > buf->size - buf->use`.
+ *
+ * @param buf  the buffer
+ * @param len  number of extra bytes to allocate
+ * @returns  0 on success, -1 in case of error
+ */
+static int
+xmlBufGrowInternal(xmlBufPtr buf, size_t len) {
+    size_t size;
+    size_t start;
+    xmlChar *newbuf;
+
+    /*
+     * If there's enough space at the start of the buffer,
+     * move the contents.
+     */
+    start = buf->content - buf->mem;
+    if (len <= start + buf->size - buf->use) {
+        memmove(buf->mem, buf->content, buf->use + 1);
+        buf->size += start;
+        buf->content = buf->mem;
+        return(0);
+    }
+
+    if (len > buf->maxSize - buf->use) {
+        xmlBufOverflowError(buf);
+        return(-1);
+    }
+
+    if (buf->size > (size_t) len) {
+        if (buf->size <= buf->maxSize / 2)
+            size = buf->size * 2;
+        else
+            size = buf->maxSize;
+    } else {
+        size = buf->use + len;
+        if (size <= buf->maxSize - 100)
+            size += 100;
+    }
+
+    if (buf->content == buf->mem) {
+        newbuf = xmlRealloc(buf->mem, size + 1);
+        if (newbuf == NULL) {
+            xmlBufMemoryError(buf);
+            return(-1);
+        }
+    } else {
+        newbuf = xmlMalloc(size + 1);
+        if (newbuf == NULL) {
+            xmlBufMemoryError(buf);
+            return(-1);
+        }
+        if (buf->content != NULL)
+            memcpy(newbuf, buf->content, buf->use + 1);
+        xmlFree(buf->mem);
+    }
+
+    buf->mem = newbuf;
+    buf->content = newbuf;
+    buf->size = size;
+
+    return(0);
+}
+
+/**
+ * Grow a buffer.
+ *
+ * Increase the capacity of a buffer. `len` is the amount of
+ * free space required after the current end of the buffer.
+ *
+ * @param buf  the buffer
+ * @param len  number of extra bytes to allocate
+ * @returns  0 on success, -1 in case of error
+ */
+int
+xmlBufGrow(xmlBuf *buf, size_t len) {
+    if ((buf == NULL) || (BUF_ERROR(buf)) || (BUF_STATIC(buf)))
+        return(-1);
+
+    if (len <= buf->size - buf->use)
+        return(0);
+
+    if (xmlBufGrowInternal(buf, len) < 0)
+        return(-1);
+
+    return(0);
+}
+
+/**
+ * Get pointer into buffer content.
+ *
+ * @param buf  the buffer
+ * @returns  the internal content or NULL in case of error
+ */
+xmlChar *
+xmlBufContent(const xmlBuf *buf)
+{
+    if ((!buf) || (BUF_ERROR(buf)))
+        return NULL;
+
+    return(buf->content);
+}
+
+/**
+ * Return a pointer to the end of the buffer content.
+ *
+ * @param buf  the buffer
+ * @returns  the end of the internal content or NULL in case of error
+ */
+xmlChar *
+xmlBufEnd(xmlBuf *buf)
+{
+    if ((!buf) || (BUF_ERROR(buf)))
+        return NULL;
+
+    return(&buf->content[buf->use]);
+}
+
+/**
+ * Increase the size of the buffer content.
+ *
+ * If data was appended by writing directly into the content
+ * array, this function increases the buffer size.
+ *
+ * @param buf  the buffer
+ * @param len  number of bytes to add
+ * @returns  0 on success, -1 in case of error
+ */
+int
+xmlBufAddLen(xmlBuf *buf, size_t len) {
+    if ((buf == NULL) || (BUF_ERROR(buf)) || (BUF_STATIC(buf)))
+        return(-1);
+    if (len > buf->size - buf->use)
+        return(-1);
+    buf->use += len;
+    buf->content[buf->use] = 0;
+    return(0);
+}
+
+/**
+ * Return the size of the buffer content.
+ *
+ * @param buf  the buffer
+ * @returns  size of buffer content in bytes
+ */
+size_t
+xmlBufUse(xmlBuf *buf)
+{
+    if ((!buf) || (BUF_ERROR(buf)))
+        return 0;
+
+    return(buf->use);
+}
+
+/**
+ * Return the size of available space at the end of a buffer.
+ *
+ * @param buf  the buffer
+ * @returns  available space in bytes
+ */
+size_t
+xmlBufAvail(xmlBuf *buf)
+{
+    if ((!buf) || (BUF_ERROR(buf)))
+        return 0;
+
+    return(buf->size - buf->use);
+}
+
+/**
+ * Tell if a buffer is empty
+ *
+ * @param buf  the buffer
+ * @returns  0 if no, 1 if yes and -1 in case of error
+ */
+int
+xmlBufIsEmpty(xmlBuf *buf)
+{
+    if ((!buf) || (BUF_ERROR(buf)))
+        return(-1);
+
+    return(buf->use == 0);
+}
+
+/**
+ * Append data to a buffer.
+ *
+ * If `len` is -1, `str` is expected to be zero-terminated.
+ *
+ * @param buf  the buffer
+ * @param str  bytes to add
+ * @param len  number of bytes
+ * @returns  0 if successful, -1 in case of error.
+ */
+int
+xmlBufAdd(xmlBuf *buf, const xmlChar *str, size_t len) {
+    if ((buf == NULL) || (BUF_ERROR(buf)) || (BUF_STATIC(buf)))
+        return(-1);
+    if (len == 0)
+        return(0);
+    if (str == NULL)
+	return(-1);
+
+    if (len > buf->size - buf->use) {
+        if (xmlBufGrowInternal(buf, len) < 0)
+            return(-1);
+    }
+
+    memmove(&buf->content[buf->use], str, len);
+    buf->use += len;
+    buf->content[buf->use] = 0;
+
+    return(0);
+}
+
+/**
+ * Append a zero-terminated string to a buffer.
+ *
+ * @param buf  the buffer
+ * @param str  string (optional)
+ * @returns  0 if successful, -1 in case of error.
+ */
+int
+xmlBufCat(xmlBuf *buf, const xmlChar *str) {
+    if (str == NULL)
+        return(0);
+    return(xmlBufAdd(buf, str, strlen((const char *) str)));
+}
+
+/**
+ * Helper routine to switch from the old buffer structures in use
+ * in various APIs. It creates a wrapper xmlBuf which will be
+ * used for internal processing until xmlBufBackToBuffer is
+ * issued.
+ *
+ * @param buffer  incoming old buffer to convert to a new one
+ * @returns  a new xmlBuf unless the call failed and NULL is returned
+ */
+xmlBuf *
+xmlBufFromBuffer(xmlBuffer *buffer) {
+    xmlBufPtr ret;
+
+    if (buffer == NULL)
+        return(NULL);
+
+    ret = xmlMalloc(sizeof(xmlBuf));
+    if (ret == NULL)
+        return(NULL);
+
+    ret->use = buffer->use;
+    ret->flags = 0;
+    ret->maxSize = SIZE_MAX - 1;
+
+    if (buffer->content == NULL) {
+        ret->size = 50;
+        ret->mem = xmlMalloc(ret->size + 1);
+        ret->content = ret->mem;
+        if (ret->mem == NULL)
+            xmlBufMemoryError(ret);
+        else
+            ret->content[0] = 0;
+    } else {
+        ret->size = buffer->size - 1;
+        ret->content = buffer->content;
+        if (buffer->alloc == XML_BUFFER_ALLOC_IO)
+            ret->mem = buffer->contentIO;
+        else
+            ret->mem = buffer->content;
+    }
+
+    return(ret);
+}
+
+/**
+ * Function to be called once internal processing had been done to
+ * update back the buffer provided by the user. This can lead to
+ * a failure in case the size accumulated in the xmlBuf is larger
+ * than what an xmlBuffer can support on 64 bits (INT_MAX)
+ * The xmlBuf `buf` wrapper is deallocated by this call in any case.
+ *
+ * @param buf  new buffer wrapping the old one
+ * @param ret  old buffer
+ * @returns  0 on success, -1 on error.
+ */
+int
+xmlBufBackToBuffer(xmlBuf *buf, xmlBuffer *ret) {
+    if ((buf == NULL) || (ret == NULL))
+        return(-1);
+
+    if ((BUF_ERROR(buf)) || (BUF_STATIC(buf)) ||
+        (buf->use >= INT_MAX)) {
+        xmlBufFree(buf);
+        ret->content = NULL;
+        ret->contentIO = NULL;
+        ret->use = 0;
+        ret->size = 0;
+        return(-1);
+    }
+
+    ret->use = buf->use;
+    if (buf->size >= INT_MAX) {
+        /* Keep the buffer but provide a truncated size value. */
+        ret->size = INT_MAX;
+    } else {
+        ret->size = buf->size + 1;
+    }
+    ret->alloc = XML_BUFFER_ALLOC_IO;
+    ret->content = buf->content;
+    ret->contentIO = buf->mem;
+    xmlFree(buf);
+    return(0);
+}
+
+/**
+ * Update pointers in the parser input struct.
+ *
+ * Update `base`, `cur` and `end` to point into the buffer.
+ * This is required after the content array was reallocated.
+ *
+ * @param buf  a buffer
+ * @param input  a parser input
+ * @returns  0 on success, -1 in case of error.
+ */
+int
+xmlBufResetInput(xmlBuf *buf, xmlParserInput *input) {
+    return(xmlBufUpdateInput(buf, input, 0));
+}
+
+/**
+ * Update pointers in the parser input struct.
+ *
+ * Update `base`, `cur` and `end` to point into the buffer.
+ * This is required after the content array was reallocated.
+ *
+ * @param buf  a buffer
+ * @param input  a parser input
+ * @param pos  the `cur` position relative to the start of the
+ *             buffer
+ * @returns  0 on success, -1 in case of error.
+ */
+int
+xmlBufUpdateInput(xmlBuf *buf, xmlParserInput *input, size_t pos) {
+    if ((buf == NULL) || (input == NULL))
+        return(-1);
+    input->base = buf->content;
+    input->cur = input->base + pos;
+    input->end = &buf->content[buf->use];
+    return(0);
+}
+
+/************************************************************************
+ *									*
+ *			Old buffer implementation			*
+ *									*
+ ************************************************************************/
+
+/**
+ * Set the buffer allocation scheme.
+ *
+ * @deprecated No-op, allocation schemes were removed.
+ *
+ * @param scheme  allocation method to use
+ */
+void
+xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme ATTRIBUTE_UNUSED) {
+}
+
+/**
+ * Get the buffer allocation scheme.
+ *
+ * @deprecated Allocation schemes were removed.
+ *
+ * @returns  the current allocation scheme
+ */
+xmlBufferAllocationScheme
+xmlGetBufferAllocationScheme(void) {
+    return(XML_BUFFER_ALLOC_EXACT);
+}
+
+/**
+ * Create a buffer.
+ *
+ * The default initial size is 256.
+ *
+ * @returns  the new structure.
+ */
+xmlBuffer *
+xmlBufferCreate(void) {
+    xmlBufferPtr ret;
+
+    ret = xmlMalloc(sizeof(*ret));
+    if (ret == NULL)
+        return(NULL);
+
+    ret->use = 0;
+    ret->size = 256;
+    ret->alloc = XML_BUFFER_ALLOC_IO;
+    ret->contentIO = xmlMalloc(ret->size);
+    if (ret->contentIO == NULL) {
+	xmlFree(ret);
+        return(NULL);
+    }
+    ret->content = ret->contentIO;
+    ret->content[0] = 0;
+
+    return(ret);
+}
+
+/**
+ * Create a buffer with an initial size.
+ *
+ * @param size  initial size of buffer
+ * @returns  the new structure.
+ */
+xmlBuffer *
+xmlBufferCreateSize(size_t size) {
+    xmlBufferPtr ret;
+
+    if (size >= INT_MAX)
+        return(NULL);
+
+    ret = xmlMalloc(sizeof(*ret));
+    if (ret == NULL)
+        return(NULL);
+
+    ret->use = 0;
+    ret->alloc = XML_BUFFER_ALLOC_IO;
+    ret->size = (size ? size + 1 : 0);         /* +1 for ending null */
+
+    if (ret->size) {
+        ret->contentIO = xmlMalloc(ret->size);
+        if (ret->contentIO == NULL) {
+            xmlFree(ret);
+            return(NULL);
+        }
+        ret->content = ret->contentIO;
+        ret->content[0] = 0;
+    } else {
+        ret->contentIO = NULL;
+	ret->content = NULL;
+    }
+
+    return(ret);
+}
+
+/**
+ * Extract buffer content.
+ *
+ * Return the contents of the buffer as an `xmlChar` string,
+ * clearing the buffer.
+ *
+ * This doesn't work with static buffers as they can't be reset.
+ *
+ * @param buf  the buffer
+ * @returns  the buffer content
+ */
+xmlChar *
+xmlBufferDetach(xmlBuffer *buf) {
+    xmlChar *ret;
+
+    if (buf == NULL)
+        return(NULL);
+
+    if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
+        (buf->content != buf->contentIO)) {
+        ret = xmlStrndup(buf->content, buf->use);
+        xmlFree(buf->contentIO);
+    } else {
+        ret = buf->content;
+    }
+
+    buf->contentIO = NULL;
+    buf->content = NULL;
+    buf->size = 0;
+    buf->use = 0;
+
+    return ret;
+}
+
+/**
+ * Create a static buffer.
+ *
+ * The memory must be zero-terminated and not be modified for the
+ * lifetime of the buffer. A static buffer can't be grown, modified or
+ * detached, but it can be shrunk.
+ *
+ * @param mem  the memory area
+ * @param size  the size in bytes
+ * @returns  a new buffer
+ */
+xmlBuffer *
+xmlBufferCreateStatic(void *mem, size_t size) {
+    xmlBufferPtr buf = xmlBufferCreateSize(size);
+
+    xmlBufferAdd(buf, mem, size);
+    return(buf);
+}
+
+/**
+ * Set the allocation scheme of a buffer.
+ *
+ * For libxml2 before 2.14, it is recommended to set this to
+ * XML_BUFFER_ALLOC_DOUBLE_IT. Has no effect on 2.14 or later.
+ *
+ * @param buf  the buffer to tune
+ * @param scheme  allocation scheme to use
+ */
+void
+xmlBufferSetAllocationScheme(xmlBuffer *buf ATTRIBUTE_UNUSED,
+                             xmlBufferAllocationScheme scheme ATTRIBUTE_UNUSED) {
+}
+
+/**
+ * Free a buffer.
+ *
+ * @param buf  the buffer to free
+ */
+void
+xmlBufferFree(xmlBuffer *buf) {
+    if (buf == NULL)
+	return;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IO)
+        xmlFree(buf->contentIO);
+    else
+        xmlFree(buf->content);
+
+    xmlFree(buf);
+}
+
+/**
+ * Empty a buffer.
+ *
+ * @param buf  the buffer
+ */
+void
+xmlBufferEmpty(xmlBuffer *buf) {
+    if (buf == NULL)
+        return;
+    if (buf->content == NULL)
+        return;
+
+    buf->use = 0;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IO) {
+	buf->size += buf->content - buf->contentIO;
+        buf->content = buf->contentIO;
+        buf->content[0] = 0;
+    } else {
+        buf->content[0] = 0;
+    }
+}
+
+/**
+ * Discard bytes at the start of a buffer.
+ *
+ * @deprecated Internal function, don't use.
+ *
+ * @param buf  the buffer
+ * @param len  the number of bytes to remove
+ * @returns  the number of bytes removed, or -1 in case of failure.
+ */
+int
+xmlBufferShrink(xmlBuffer *buf, unsigned int len) {
+    if (buf == NULL)
+        return(-1);
+    if (len == 0)
+        return(0);
+    if (len > buf->use)
+        return(-1);
+
+    buf->use -= len;
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IO) {
+        buf->content += len;
+	buf->size -= len;
+    } else {
+	memmove(buf->content, &buf->content[len], buf->use + 1);
+    }
+
+    return(len);
+}
+
+/**
+ * Grow a buffer.
+ *
+ * @deprecated Internal function, don't use.
+ *
+ * @param buf  the buffer
+ * @param len  number of extra bytes to allocate
+ * @returns  the new available space or -1 in case of error
+ */
+int
+xmlBufferGrow(xmlBuffer *buf, unsigned int len) {
+    unsigned int size;
+    xmlChar *newbuf;
+
+    if (buf == NULL)
+        return(-1);
+
+    if (len < buf->size - buf->use)
+        return(0);
+    if (len >= INT_MAX - buf->use)
+        return(-1);
+
+    if (buf->size > (size_t) len) {
+        if (buf->size <= INT_MAX / 2)
+            size = buf->size * 2;
+        else
+            size = INT_MAX;
+    } else {
+        size = buf->use + len + 1;
+        if (size <= INT_MAX - 100)
+            size += 100;
+    }
+
+    if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
+        (buf->content != buf->contentIO)) {
+        newbuf = xmlMalloc(size);
+        if (newbuf == NULL)
+            return(-1);
+        if (buf->content != NULL)
+            memcpy(newbuf, buf->content, buf->use + 1);
+        xmlFree(buf->contentIO);
+    } else {
+        newbuf = xmlRealloc(buf->content, size);
+        if (newbuf == NULL)
+            return(-1);
+    }
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IO)
+        buf->contentIO = newbuf;
+    buf->content = newbuf;
+    buf->size = size;
+
+    return(buf->size - buf->use - 1);
+}
+
+/**
+ * Dump a buffer to a `FILE`.
+ *
+ * @param file  the output file
+ * @param buf  the buffer
+ * @returns  the number of bytes written
+ */
+int
+xmlBufferDump(FILE *file, xmlBuffer *buf) {
+    size_t ret;
+
+    if (buf == NULL)
+	return(0);
+    if (buf->content == NULL)
+	return(0);
+    if (file == NULL)
+	file = stdout;
+    ret = fwrite(buf->content, 1, buf->use, file);
+    return(ret > INT_MAX ? INT_MAX : ret);
+}
+
+/**
+ * Get pointer into buffer content.
+ *
+ * @param buf  the buffer
+ * @returns  the internal content
+ */
+const xmlChar *
+xmlBufferContent(const xmlBuffer *buf)
+{
+    if(!buf)
+        return NULL;
+
+    return buf->content;
+}
+
+/**
+ * Get the size of the buffer content.
+ *
+ * @param buf  the buffer
+ * @returns  the size of the buffer content in bytes
+ */
+int
+xmlBufferLength(const xmlBuffer *buf)
+{
+    if(!buf)
+        return 0;
+
+    return buf->use;
+}
+
+/**
+ * Resize a buffer to a minimum size.
+ *
+ * @deprecated Internal function, don't use.
+ *
+ * @param buf  the buffer to resize
+ * @param size  the desired size
+ * @returns  1 on succes, 0 in case of error
+ */
+int
+xmlBufferResize(xmlBuffer *buf, unsigned int size)
+{
+    int res;
+
+    if (buf == NULL)
+        return(0);
+    if (size < buf->size)
+        return(1);
+    res = xmlBufferGrow(buf, size - buf->use);
+
+    return(res < 0 ? 0 : 1);
+}
+
+/**
+ * Append bytes to a buffer.
+ *
+ * If `len` is -1, `str` is assumed to be zero-terminated.
+ *
+ * @param buf  the buffer
+ * @param str  bytes to add 
+ * @param len  number of bytes
+ * @returns  an xmlParserErrors code.
+ */
+int
+xmlBufferAdd(xmlBuffer *buf, const xmlChar *str, int len) {
+    if ((buf == NULL) || (str == NULL))
+	return(XML_ERR_ARGUMENT);
+    if (len < 0)
+        len = xmlStrlen(str);
+    if (len == 0)
+        return(XML_ERR_OK);
+
+    /* Note that both buf->size and buf->use can be zero here. */
+    if ((unsigned) len >= buf->size - buf->use) {
+        if (xmlBufferGrow(buf, len) < 0)
+            return(XML_ERR_NO_MEMORY);
+    }
+
+    memmove(&buf->content[buf->use], str, len);
+    buf->use += len;
+    buf->content[buf->use] = 0;
+    return(XML_ERR_OK);
+}
+
+/**
+ * Prepend bytes to a buffer.
+ *
+ * If `len` is -1, `str` is assumed to be zero-terminated.
+ *
+ * @param buf  the buffer
+ * @param str  bytes to prepend
+ * @param len  number of bytes
+ * @returns  an xmlParserErrors code.
+ */
+int
+xmlBufferAddHead(xmlBuffer *buf, const xmlChar *str, int len) {
+    unsigned start = 0;
+
+    if ((buf == NULL) || (str == NULL))
+	return(XML_ERR_ARGUMENT);
+    if (len < 0)
+        len = xmlStrlen(str);
+    if (len == 0)
+        return(XML_ERR_OK);
+
+    if (buf->alloc == XML_BUFFER_ALLOC_IO) {
+        start = buf->content - buf->contentIO;
+
+        /*
+         * We can add it in the space previously shrunk
+         */
+        if ((unsigned) len <= start) {
+            buf->content -= len;
+            memmove(&buf->content[0], str, len);
+            buf->use += len;
+            buf->size += len;
+            return(0);
+        }
+        if ((unsigned) len < buf->size + start - buf->use) {
+            memmove(&buf->contentIO[len], buf->content, buf->use + 1);
+            memmove(buf->contentIO, str, len);
+            buf->content = buf->contentIO;
+            buf->use += len;
+            buf->size += start;
+            return(0);
+        }
+    }
+
+    if ((unsigned) len >= buf->size - buf->use) {
+        if (xmlBufferGrow(buf, len) < 0)
+            return(-1);
+    }
+
+    memmove(&buf->content[len], buf->content, buf->use + 1);
+    memmove(buf->content, str, len);
+    buf->use += len;
+    return (0);
+}
+
+/**
+ * Append a zero-terminated string to a buffer.
+ *
+ * @param buf  the buffer
+ * @param str  string to add
+ * @returns  an xmlParserErrors code.
+ */
+int
+xmlBufferCat(xmlBuffer *buf, const xmlChar *str) {
+    return(xmlBufferAdd(buf, str, -1));
+}
+
+/**
+ * Append a zero-terminated C string to a buffer.
+ *
+ * @param buf  the buffer
+ * @param str  string to add
+ * @returns  an xmlParserErrors code.
+ */
+int
+xmlBufferCCat(xmlBuffer *buf, const char *str) {
+    return(xmlBufferAdd(buf, (const xmlChar *) str, -1));
+}
+
+/**
+ * Append a zero-terminated `xmlChar` string to a buffer.
+ *
+ * @param buf  the XML buffer
+ * @param string  the string to add
+ */
+void
+xmlBufferWriteCHAR(xmlBuffer *buf, const xmlChar *string) {
+    xmlBufferAdd(buf, string, -1);
+}
+
+/**
+ * Append a zero-terminated C string to a buffer.
+ *
+ * Same as #xmlBufferCCat.
+ *
+ * @param buf  the buffer
+ * @param string  the string to add
+ */
+void
+xmlBufferWriteChar(xmlBuffer *buf, const char *string) {
+    xmlBufferAdd(buf, (const xmlChar *) string, -1);
+}
+
+/**
+ * Append a quoted string to a buffer.
+ *
+ * Append a string quoted with single or double quotes. If the
+ * string contains both single and double quotes, double quotes
+ * are escaped with `&quot;`.
+ *
+ * @param buf  the buffer
+ * @param string  the string to add
+ */
+void
+xmlBufferWriteQuotedString(xmlBuffer *buf, const xmlChar *string) {
+    const xmlChar *cur, *base;
+    if (buf == NULL)
+        return;
+    if (xmlStrchr(string, '\"')) {
+        if (xmlStrchr(string, '\'')) {
+	    xmlBufferCCat(buf, "\"");
+            base = cur = string;
+            while(*cur != 0){
+                if(*cur == '"'){
+                    if (base != cur)
+                        xmlBufferAdd(buf, base, cur - base);
+                    xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
+                    cur++;
+                    base = cur;
+                }
+                else {
+                    cur++;
+                }
+            }
+            if (base != cur)
+                xmlBufferAdd(buf, base, cur - base);
+	    xmlBufferCCat(buf, "\"");
+	}
+        else{
+	    xmlBufferCCat(buf, "\'");
+            xmlBufferCat(buf, string);
+	    xmlBufferCCat(buf, "\'");
+        }
+    } else {
+        xmlBufferCCat(buf, "\"");
+        xmlBufferCat(buf, string);
+        xmlBufferCCat(buf, "\"");
+    }
+}
+

c14n.c

@@ -0,0 +1,2171 @@
+/*
+ * "Canonical XML" implementation
+ * http://www.w3.org/TR/xml-c14n
+ *
+ * "Exclusive XML Canonicalization" implementation
+ * http://www.w3.org/TR/xml-exc-c14n
+ *
+ * See Copyright for the status of this software.
+ *
+ * Author: Aleksey Sanin
+ */
+#define IN_LIBXML
+#include "libxml.h"
+#ifdef LIBXML_C14N_ENABLED
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/uri.h>
+#include <libxml/xmlerror.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/c14n.h>
+
+#include "private/error.h"
+#include "private/io.h"
+#include "private/memory.h"
+
+/************************************************************************
+ *									*
+ *		Some declaration better left private ATM		*
+ *									*
+ ************************************************************************/
+
+typedef enum {
+    XMLC14N_BEFORE_DOCUMENT_ELEMENT = 0,
+    XMLC14N_INSIDE_DOCUMENT_ELEMENT = 1,
+    XMLC14N_AFTER_DOCUMENT_ELEMENT = 2
+} xmlC14NPosition;
+
+typedef struct _xmlC14NVisibleNsStack {
+    int nsCurEnd;           /* number of nodes in the set */
+    int nsPrevStart;        /* the beginning of the stack for previous visible node */
+    int nsPrevEnd;          /* the end of the stack for previous visible node */
+    int nsMax;              /* size of the array as allocated */
+    xmlNsPtr	*nsTab;	    /* array of ns in no particular order */
+    xmlNodePtr	*nodeTab;   /* array of nodes in no particular order */
+} xmlC14NVisibleNsStack, *xmlC14NVisibleNsStackPtr;
+
+typedef struct _xmlC14NCtx {
+    /* input parameters */
+    xmlDocPtr doc;
+    xmlC14NIsVisibleCallback is_visible_callback;
+    void* user_data;
+    int with_comments;
+    xmlOutputBufferPtr buf;
+
+    /* position in the XML document */
+    xmlC14NPosition pos;
+    int parent_is_doc;
+    xmlC14NVisibleNsStackPtr ns_rendered;
+
+    /* C14N mode */
+    xmlC14NMode mode;
+
+    /* exclusive canonicalization */
+    xmlChar **inclusive_ns_prefixes;
+
+    /* error number */
+    int error;
+} xmlC14NCtx, *xmlC14NCtxPtr;
+
+static xmlC14NVisibleNsStackPtr	xmlC14NVisibleNsStackCreate	(void);
+static void     xmlC14NVisibleNsStackDestroy	(xmlC14NVisibleNsStackPtr cur);
+static int      xmlC14NVisibleNsStackAdd	    (xmlC14NVisibleNsStackPtr cur,
+                                                 xmlNsPtr ns,
+                                                 xmlNodePtr node);
+static void			xmlC14NVisibleNsStackSave	(xmlC14NVisibleNsStackPtr cur,
+								 xmlC14NVisibleNsStackPtr state);
+static void			xmlC14NVisibleNsStackRestore	(xmlC14NVisibleNsStackPtr cur,
+								 xmlC14NVisibleNsStackPtr state);
+static void			xmlC14NVisibleNsStackShift	(xmlC14NVisibleNsStackPtr cur);
+static int			xmlC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur,
+								 xmlNsPtr ns);
+static int			xmlExcC14NVisibleNsStackFind	(xmlC14NVisibleNsStackPtr cur,
+								 xmlNsPtr ns,
+								 xmlC14NCtxPtr ctx);
+
+static int			xmlC14NIsNodeInNodeset		(void *user_data,
+								 xmlNodePtr node,
+								 xmlNodePtr parent);
+
+
+
+static int xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur);
+static int xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur);
+typedef enum {
+    XMLC14N_NORMALIZE_ATTR = 0,
+    XMLC14N_NORMALIZE_COMMENT = 1,
+    XMLC14N_NORMALIZE_PI = 2,
+    XMLC14N_NORMALIZE_TEXT = 3
+} xmlC14NNormalizationMode;
+
+static xmlChar *xmlC11NNormalizeString(const xmlChar * input,
+                                       xmlC14NNormalizationMode mode);
+
+#define	xmlC11NNormalizeAttr( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_ATTR)
+#define	xmlC11NNormalizeComment( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_COMMENT)
+#define	xmlC11NNormalizePI( a )	\
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_PI)
+#define	xmlC11NNormalizeText( a ) \
+    xmlC11NNormalizeString((a), XMLC14N_NORMALIZE_TEXT)
+
+#define	xmlC14NIsVisible( ctx, node, parent ) \
+     (((ctx)->is_visible_callback != NULL) ? \
+	(ctx)->is_visible_callback((ctx)->user_data, \
+		(xmlNodePtr)(node), (xmlNodePtr)(parent)) : 1)
+
+#define	xmlC14NIsExclusive( ctx ) \
+    ( (ctx)->mode == XML_C14N_EXCLUSIVE_1_0 )
+
+/************************************************************************
+ *									*
+ *		Some factorized error routines				*
+ *									*
+ ************************************************************************/
+
+/**
+ * Handle a redefinition of memory error
+ *
+ * @param ctxt  a C14N evaluation context
+ */
+static void
+xmlC14NErrMemory(xmlC14NCtxPtr ctxt)
+{
+    if (ctxt != NULL)
+        ctxt->error = XML_ERR_NO_MEMORY;
+
+    xmlRaiseMemoryError(NULL, NULL, NULL, XML_FROM_C14N, NULL);
+}
+
+static void
+xmlC14NErrFull(xmlC14NCtxPtr ctxt, xmlNodePtr node, int code, const char *str1,
+               const char *msg, ...)
+{
+    va_list ap;
+    int res;
+
+    if (ctxt != NULL)
+        ctxt->error = code;
+
+    va_start(ap, msg);
+    res = xmlVRaiseError(NULL, NULL, NULL, ctxt, node,
+                         XML_FROM_C14N, code, XML_ERR_ERROR, NULL, 0,
+                         str1, NULL, NULL, 0, 0,
+                         msg, ap);
+    va_end(ap);
+    if (res < 0)
+        xmlC14NErrMemory(ctxt);
+}
+
+/**
+ * Handle a param error
+ *
+ * @param ctxt  a C14N evaluation context
+ */
+static void
+xmlC14NErrParam(xmlC14NCtxPtr ctxt)
+{
+    xmlC14NErrFull(ctxt, NULL, XML_ERR_ARGUMENT, NULL,
+		   "Invalid argument\n", NULL);
+}
+
+/**
+ * Handle an invalid node error
+ *
+ * @param ctxt  a C14N evaluation context
+ * @param node_type  node type
+ * @param extra  extra information
+ */
+static void
+xmlC14NErrInvalidNode(xmlC14NCtxPtr ctxt, const char *node_type,
+                      const char *extra)
+{
+    xmlC14NErrFull(ctxt, NULL, XML_C14N_INVALID_NODE, extra,
+		   "Node %s is invalid here : %s\n", node_type, extra);
+}
+
+/**
+ * Handle an unknown node error
+ *
+ * @param ctxt  a C14N evaluation context
+ * @param node_type  node type
+ * @param extra  extra information
+ */
+static void
+xmlC14NErrUnknownNode(xmlC14NCtxPtr ctxt, int node_type, const char *extra)
+{
+    xmlC14NErrFull(ctxt, NULL, XML_C14N_UNKNOW_NODE, extra,
+		   "Unknown node type %d found : %s\n", node_type, extra);
+}
+
+/**
+ * Handle a relative namespace error
+ *
+ * @param ctxt  a C14N evaluation context
+ * @param ns_uri  namespace URI
+ */
+static void
+xmlC14NErrRelativeNamespace(xmlC14NCtxPtr ctxt, const char *ns_uri)
+{
+    xmlC14NErrFull(ctxt, NULL, XML_C14N_RELATIVE_NAMESPACE, ns_uri,
+		   "Relative namespace UR is invalid here : %s\n", ns_uri);
+}
+
+
+
+/**
+ * Handle an error
+ *
+ * @param ctxt  a C14N evaluation context
+ * @param node  the context node
+ * @param error  the error code
+ * @param msg  the message
+ */
+static void
+xmlC14NErr(xmlC14NCtxPtr ctxt, xmlNodePtr node, int error,
+           const char * msg)
+{
+    xmlC14NErrFull(ctxt, node, error, NULL, "%s", msg);
+}
+
+/************************************************************************
+ *									*
+ *		The implementation internals				*
+ *									*
+ ************************************************************************/
+#define XML_NAMESPACES_DEFAULT		16
+
+static int
+xmlC14NIsNodeInNodeset(void *user_data, xmlNodePtr node, xmlNodePtr parent) {
+    xmlNodeSetPtr nodes = (xmlNodeSetPtr) user_data;
+    if((nodes != NULL) && (node != NULL)) {
+	if(node->type != XML_NAMESPACE_DECL) {
+	    return(xmlXPathNodeSetContains(nodes, node));
+	} else {
+	    xmlNs ns;
+
+	    memcpy(&ns, node, sizeof(ns));
+
+	    /* this is a libxml hack! check xpath.c for details */
+	    if((parent != NULL) && (parent->type == XML_ATTRIBUTE_NODE)) {
+		ns.next = (xmlNsPtr)parent->parent;
+	    } else {
+		ns.next = (xmlNsPtr)parent;
+	    }
+
+	    /*
+	     * If the input is an XPath node-set, then the node-set must explicitly
+	     * contain every node to be rendered to the canonical form.
+	     */
+	    return(xmlXPathNodeSetContains(nodes, (xmlNodePtr)&ns));
+	}
+    }
+    return(1);
+}
+
+static xmlC14NVisibleNsStackPtr
+xmlC14NVisibleNsStackCreate(void) {
+    xmlC14NVisibleNsStackPtr ret;
+
+    ret = (xmlC14NVisibleNsStackPtr) xmlMalloc(sizeof(xmlC14NVisibleNsStack));
+    if (ret == NULL)
+	return(NULL);
+    memset(ret, 0, sizeof(xmlC14NVisibleNsStack));
+    return(ret);
+}
+
+static void
+xmlC14NVisibleNsStackDestroy(xmlC14NVisibleNsStackPtr cur) {
+    if(cur == NULL) {
+        xmlC14NErrParam(NULL);
+        return;
+    }
+    if(cur->nsTab != NULL) {
+	memset(cur->nsTab, 0, cur->nsMax * sizeof(xmlNsPtr));
+	xmlFree(cur->nsTab);
+    }
+    if(cur->nodeTab != NULL) {
+	memset(cur->nodeTab, 0, cur->nsMax * sizeof(xmlNodePtr));
+	xmlFree(cur->nodeTab);
+    }
+    memset(cur, 0, sizeof(xmlC14NVisibleNsStack));
+    xmlFree(cur);
+
+}
+
+static int
+xmlC14NVisibleNsStackAdd(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlNodePtr node) {
+    if((cur == NULL) ||
+       ((cur->nsTab == NULL) && (cur->nodeTab != NULL)) ||
+       ((cur->nsTab != NULL) && (cur->nodeTab == NULL)))
+	return (1);
+
+    if (cur->nsMax <= cur->nsCurEnd) {
+	xmlNsPtr *tmp1;
+        xmlNodePtr *tmp2;
+	int newSize;
+
+        newSize = xmlGrowCapacity(cur->nsMax,
+                                  sizeof(tmp1[0]) + sizeof(tmp2[0]),
+                                  XML_NAMESPACES_DEFAULT, XML_MAX_ITEMS);
+
+	tmp1 = xmlRealloc(cur->nsTab, newSize * sizeof(tmp1[0]));
+	if (tmp1 == NULL)
+	    return (-1);
+	cur->nsTab = tmp1;
+
+	tmp2 = xmlRealloc(cur->nodeTab, newSize * sizeof(tmp2[0]));
+	if (tmp2 == NULL)
+	    return (-1);
+	cur->nodeTab = tmp2;
+
+	cur->nsMax = newSize;
+    }
+    cur->nsTab[cur->nsCurEnd] = ns;
+    cur->nodeTab[cur->nsCurEnd] = node;
+
+    ++cur->nsCurEnd;
+
+    return (0);
+}
+
+static void
+xmlC14NVisibleNsStackSave(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
+    if((cur == NULL) || (state == NULL)) {
+        xmlC14NErrParam(NULL);
+	return;
+    }
+
+    state->nsCurEnd = cur->nsCurEnd;
+    state->nsPrevStart = cur->nsPrevStart;
+    state->nsPrevEnd = cur->nsPrevEnd;
+}
+
+static void
+xmlC14NVisibleNsStackRestore(xmlC14NVisibleNsStackPtr cur, xmlC14NVisibleNsStackPtr state) {
+    if((cur == NULL) || (state == NULL)) {
+        xmlC14NErrParam(NULL);
+	return;
+    }
+    cur->nsCurEnd = state->nsCurEnd;
+    cur->nsPrevStart = state->nsPrevStart;
+    cur->nsPrevEnd = state->nsPrevEnd;
+}
+
+static void
+xmlC14NVisibleNsStackShift(xmlC14NVisibleNsStackPtr cur) {
+    if(cur == NULL) {
+        xmlC14NErrParam(NULL);
+	return;
+    }
+    cur->nsPrevStart = cur->nsPrevEnd;
+    cur->nsPrevEnd = cur->nsCurEnd;
+}
+
+static int
+xmlC14NStrEqual(const xmlChar *str1, const xmlChar *str2) {
+    if (str1 == str2) return(1);
+    if (str1 == NULL) return((*str2) == '\0');
+    if (str2 == NULL) return((*str1) == '\0');
+    do {
+	if (*str1++ != *str2) return(0);
+    } while (*str2++);
+    return(1);
+}
+
+/**
+ * Checks whether the given namespace was already rendered or not
+ *
+ * @param cur  		the visible stack
+ * @param ns  			the namespace to check
+ * @returns 1 if we already wrote this namespace or 0 otherwise
+ */
+static int
+xmlC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns)
+{
+    int i;
+    const xmlChar *prefix;
+    const xmlChar *href;
+    int has_empty_ns;
+
+    if(cur == NULL) {
+        xmlC14NErrParam(NULL);
+        return (0);
+    }
+
+    /*
+     * if the default namespace xmlns="" is not defined yet then
+     * we do not want to print it out
+     */
+    prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
+    href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
+    has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
+
+    if (cur->nsTab != NULL) {
+	int start = (has_empty_ns) ? 0 : cur->nsPrevStart;
+        for (i = cur->nsCurEnd - 1; i >= start; --i) {
+            xmlNsPtr ns1 = cur->nsTab[i];
+
+	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
+		return(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL));
+	    }
+        }
+    }
+    return(has_empty_ns);
+}
+
+static int
+xmlExcC14NVisibleNsStackFind(xmlC14NVisibleNsStackPtr cur, xmlNsPtr ns, xmlC14NCtxPtr ctx) {
+    int i;
+    const xmlChar *prefix;
+    const xmlChar *href;
+    int has_empty_ns;
+
+    if(cur == NULL) {
+        xmlC14NErrParam(ctx);
+        return (0);
+    }
+
+    /*
+     * if the default namespace xmlns="" is not defined yet then
+     * we do not want to print it out
+     */
+    prefix = ((ns == NULL) || (ns->prefix == NULL)) ? BAD_CAST "" : ns->prefix;
+    href = ((ns == NULL) || (ns->href == NULL)) ? BAD_CAST "" : ns->href;
+    has_empty_ns = (xmlC14NStrEqual(prefix, NULL) && xmlC14NStrEqual(href, NULL));
+
+    if (cur->nsTab != NULL) {
+	int start = 0;
+        for (i = cur->nsCurEnd - 1; i >= start; --i) {
+            xmlNsPtr ns1 = cur->nsTab[i];
+
+	    if(xmlC14NStrEqual(prefix, (ns1 != NULL) ? ns1->prefix : NULL)) {
+		if(xmlC14NStrEqual(href, (ns1 != NULL) ? ns1->href : NULL)) {
+		    return(xmlC14NIsVisible(ctx, ns1, cur->nodeTab[i]));
+		} else {
+		    return(0);
+		}
+	    }
+        }
+    }
+    return(has_empty_ns);
+}
+
+
+
+
+/**
+ * Checks whether the given namespace is a default "xml:" namespace
+ * with href="http://www.w3.org/XML/1998/namespace"
+ *
+ * @param ns  		the namespace to check
+ * @returns 1 if the node is default or 0 otherwise
+ */
+
+/* todo: make it a define? */
+static int
+xmlC14NIsXmlNs(xmlNsPtr ns)
+{
+    return ((ns != NULL) &&
+            (xmlStrEqual(ns->prefix, BAD_CAST "xml")) &&
+            (xmlStrEqual(ns->href, XML_XML_NAMESPACE)));
+}
+
+
+/**
+ * Compares the namespaces by names (prefixes).
+ *
+ * @param data1  		the pointer to first namespace
+ * @param data2  		the pointer to second namespace
+ * @returns -1 if ns1 < ns2, 0 if ns1 == ns2 or 1 if ns1 > ns2.
+ */
+static int
+xmlC14NNsCompare(const void *data1, const void *data2)
+{
+    const xmlNs *ns1 = data1;
+    const xmlNs *ns2 = data2;
+    if (ns1 == ns2)
+        return (0);
+    if (ns1 == NULL)
+        return (-1);
+    if (ns2 == NULL)
+        return (1);
+
+    return (xmlStrcmp(ns1->prefix, ns2->prefix));
+}
+
+
+/**
+ * Prints the given namespace to the output buffer from C14N context.
+ *
+ * @param ns  			the pointer to namespace
+ * @param ctx  		the C14N context
+ * @returns 1 on success or 0 on fail.
+ */
+static int
+xmlC14NPrintNamespaces(const xmlNs *ns, xmlC14NCtxPtr ctx)
+{
+
+    if ((ns == NULL) || (ctx == NULL)) {
+        xmlC14NErrParam(ctx);
+        return 0;
+    }
+
+    if (ns->prefix != NULL) {
+        xmlOutputBufferWriteString(ctx->buf, " xmlns:");
+        xmlOutputBufferWriteString(ctx->buf, (const char *) ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, "=");
+    } else {
+        xmlOutputBufferWriteString(ctx->buf, " xmlns=");
+    }
+    if(ns->href != NULL) {
+	xmlOutputBufferWriteQuotedString(ctx->buf, ns->href);
+    } else {
+    	xmlOutputBufferWriteString(ctx->buf, "\"\"");
+    }
+    return (1);
+}
+
+static int
+xmlC14NPrintNamespacesWalker(const void *ns, void *ctx) {
+    return xmlC14NPrintNamespaces(ns, ctx);
+}
+
+/**
+ * Prints out canonical namespace axis of the current node to the
+ * buffer from C14N context as follows
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Namespace Axis
+ * Consider a list L containing only namespace nodes in the
+ * axis and in the node-set in lexicographic order (ascending). To begin
+ * processing L, if the first node is not the default namespace node (a node
+ * with no namespace URI and no local name), then generate a space followed
+ * by xmlns="" if and only if the following conditions are met:
+ *    - the element E that owns the axis is in the node-set
+ *    - The nearest ancestor element of E in the node-set has a default
+ *	    namespace node in the node-set (default namespace nodes always
+ *      have non-empty values in XPath)
+ * The latter condition eliminates unnecessary occurrences of xmlns="" in
+ * the canonical form since an element only receives an xmlns="" if its
+ * default namespace is empty and if it has an immediate parent in the
+ * canonical form that has a non-empty default namespace. To finish
+ * processing  L, simply process every namespace node in L, except omit
+ * namespace node with local name xml, which defines the xml prefix,
+ * if its string value is http://www.w3.org/XML/1998/namespace.
+ *
+ * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
+ * Canonical XML applied to a document subset requires the search of the
+ * ancestor nodes of each orphan element node for attributes in the xml
+ * namespace, such as xml:lang and xml:space. These are copied into the
+ * element node except if a declaration of the same attribute is already
+ * in the attribute axis of the element (whether or not it is included in
+ * the document subset). This search and copying are omitted from the
+ * Exclusive XML Canonicalization method.
+ *
+ * @param ctx  		the C14N context
+ * @param cur  		the current node
+ * @param visible  		the visibility of node
+ * @returns 0 on success or -1 on fail.
+ */
+static int
+xmlC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    xmlNodePtr n;
+    xmlNsPtr ns, tmp;
+    xmlListPtr list;
+    int already_rendered;
+    int has_empty_ns = 0;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    /*
+     * Create a sorted list to store element namespaces
+     */
+    list = xmlListCreate(NULL, xmlC14NNsCompare);
+    if (list == NULL) {
+        xmlC14NErrMemory(ctx);
+        return (-1);
+    }
+
+    /* check all namespaces */
+    for(n = cur; n != NULL; n = n->parent) {
+	for(ns = n->nsDef; ns != NULL; ns = ns->next) {
+	    tmp = xmlSearchNs(cur->doc, cur, ns->prefix);
+
+	    if((tmp == ns) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
+		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
+		if(visible) {
+	            if (xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur) < 0) {
+                        xmlC14NErrMemory(ctx);
+                        goto error;
+                    }
+		}
+		if(!already_rendered) {
+		    xmlListInsert(list, ns);
+		}
+		if(xmlStrlen(ns->prefix) == 0) {
+		    has_empty_ns = 1;
+		}
+	    }
+	}
+    }
+
+    /**
+     * if the first node is not the default namespace node (a node with no
+     * namespace URI and no local name), then generate a space followed by
+     * xmlns="" if and only if the following conditions are met:
+     *  - the element E that owns the axis is in the node-set
+     *  - the nearest ancestor element of E in the node-set has a default
+     *     namespace node in the node-set (default namespace nodes always
+     *     have non-empty values in XPath)
+     */
+    if(visible && !has_empty_ns) {
+        xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+        if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
+	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    }
+
+
+    /*
+     * print out all elements from list
+     */
+    xmlListWalk(list, xmlC14NPrintNamespacesWalker, (void *) ctx);
+
+    /*
+     * Cleanup
+     */
+error:
+    xmlListDelete(list);
+    return (0);
+}
+
+
+/**
+ * Prints out exclusive canonical namespace axis of the current node to the
+ * buffer from C14N context as follows
+ *
+ * Exclusive XML Canonicalization
+ * http://www.w3.org/TR/xml-exc-c14n
+ *
+ * If the element node is in the XPath subset then output the node in
+ * accordance with Canonical XML except for namespace nodes which are
+ * rendered as follows:
+ *
+ * 1. Render each namespace node iff:
+ *    * it is visibly utilized by the immediate parent element or one of
+ *      its attributes, or is present in InclusiveNamespaces PrefixList, and
+ *    * its prefix and value do not appear in ns_rendered. ns_rendered is
+ *      obtained by popping the state stack in order to obtain a list of
+ *      prefixes and their values which have already been rendered by
+ *      an output ancestor of the namespace node's parent element.
+ * 2. Append the rendered namespace node to the list ns_rendered of namespace
+ * nodes rendered by output ancestors. Push ns_rendered on state stack and
+ * recurse.
+ * 3. After the recursion returns, pop thestate stack.
+ *
+ *
+ * @param ctx  		the C14N context
+ * @param cur  		the current node
+ * @param visible  		the visibility of node
+ * @returns 0 on success or -1 on fail.
+ */
+static int
+xmlExcC14NProcessNamespacesAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    xmlNsPtr ns;
+    xmlListPtr list;
+    xmlAttrPtr attr;
+    int already_rendered;
+    int has_empty_ns = 0;
+    int has_visibly_utilized_empty_ns = 0;
+    int has_empty_ns_in_inclusive_list = 0;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    if(!xmlC14NIsExclusive(ctx)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+
+    }
+
+    /*
+     * Create a sorted list to store element namespaces
+     */
+    list = xmlListCreate(NULL, xmlC14NNsCompare);
+    if (list == NULL) {
+        xmlC14NErrMemory(ctx);
+        return (-1);
+    }
+
+    /*
+     * process inclusive namespaces:
+     * All namespace nodes appearing on inclusive ns list are
+     * handled as provided in Canonical XML
+     */
+    if(ctx->inclusive_ns_prefixes != NULL) {
+	xmlChar *prefix;
+	int i;
+
+	for (i = 0; ctx->inclusive_ns_prefixes[i] != NULL; ++i) {
+	    prefix = ctx->inclusive_ns_prefixes[i];
+	    /*
+	     * Special values for namespace with empty prefix
+	     */
+            if (xmlStrEqual(prefix, BAD_CAST "#default")
+                || xmlStrEqual(prefix, BAD_CAST "")) {
+                prefix = NULL;
+		has_empty_ns_in_inclusive_list = 1;
+            }
+
+	    ns = xmlSearchNs(cur->doc, cur, prefix);
+	    if((ns != NULL) && !xmlC14NIsXmlNs(ns) && xmlC14NIsVisible(ctx, ns, cur)) {
+		already_rendered = xmlC14NVisibleNsStackFind(ctx->ns_rendered, ns);
+		if(visible) {
+		    if (xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur) < 0) {
+                        xmlC14NErrMemory(ctx);
+                        goto error;
+                    }
+		}
+		if(!already_rendered) {
+		    xmlListInsert(list, ns);
+		}
+		if(xmlStrlen(ns->prefix) == 0) {
+		    has_empty_ns = 1;
+		}
+	    }
+	}
+    }
+
+    /* add node namespace */
+    if(cur->ns != NULL) {
+	ns = cur->ns;
+    } else {
+        ns = xmlSearchNs(cur->doc, cur, NULL);
+	has_visibly_utilized_empty_ns = 1;
+    }
+    if((ns != NULL) && !xmlC14NIsXmlNs(ns)) {
+	if(visible && xmlC14NIsVisible(ctx, ns, cur)) {
+	    if(!xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, ns, ctx)) {
+		xmlListInsert(list, ns);
+	    }
+	}
+	if(visible) {
+	    if (xmlC14NVisibleNsStackAdd(ctx->ns_rendered, ns, cur) < 0) {
+                xmlC14NErrMemory(ctx);
+                goto error;
+            }
+	}
+	if(xmlStrlen(ns->prefix) == 0) {
+	    has_empty_ns = 1;
+	}
+    }
+
+
+    /* add attributes */
+    for(attr = cur->properties; attr != NULL; attr = attr->next) {
+        /*
+         * we need to check that attribute is visible and has non
+         * default namespace (XML Namespaces: "default namespaces
+	 * do not apply directly to attributes")
+         */
+	if((attr->ns != NULL) && !xmlC14NIsXmlNs(attr->ns) && xmlC14NIsVisible(ctx, attr, cur)) {
+	    already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, attr->ns, ctx);
+	    if (xmlC14NVisibleNsStackAdd(ctx->ns_rendered, attr->ns, cur) < 0) {
+                xmlC14NErrMemory(ctx);
+                goto error;
+            }
+	    if(!already_rendered && visible) {
+		xmlListInsert(list, attr->ns);
+	    }
+	    if(xmlStrlen(attr->ns->prefix) == 0) {
+		has_empty_ns = 1;
+	    }
+	} else if((attr->ns != NULL) && (xmlStrlen(attr->ns->prefix) == 0) && (xmlStrlen(attr->ns->href) == 0)) {
+	    has_visibly_utilized_empty_ns = 1;
+	}
+    }
+
+    /*
+     * Process xmlns=""
+     */
+    if(visible && has_visibly_utilized_empty_ns &&
+	    !has_empty_ns && !has_empty_ns_in_inclusive_list) {
+        xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+
+        already_rendered = xmlExcC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default, ctx);
+	if(!already_rendered) {
+	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    } else if(visible && !has_empty_ns && has_empty_ns_in_inclusive_list) {
+        xmlNs ns_default;
+
+        memset(&ns_default, 0, sizeof(ns_default));
+        if(!xmlC14NVisibleNsStackFind(ctx->ns_rendered, &ns_default)) {
+	    xmlC14NPrintNamespaces(&ns_default, ctx);
+	}
+    }
+
+
+
+    /*
+     * print out all elements from list
+     */
+    xmlListWalk(list, xmlC14NPrintNamespacesWalker, (void *) ctx);
+
+    /*
+     * Cleanup
+     */
+error:
+    xmlListDelete(list);
+    return (0);
+}
+
+
+/**
+ * Checks whether the given attribute is a default "xml:" namespace
+ * with href="http://www.w3.org/XML/1998/namespace"
+ *
+ * @param attr  		the attr to check
+ * @returns 1 if the node is default or 0 otherwise
+ */
+
+/* todo: make it a define? */
+static int
+xmlC14NIsXmlAttr(xmlAttrPtr attr)
+{
+    return ((attr->ns != NULL) &&
+           (xmlC14NIsXmlNs(attr->ns) != 0));
+}
+
+
+/**
+ * Prints the given attribute to the output buffer from C14N context.
+ *
+ * @param data1  		the pointer tls o first attr
+ * @param data2  		the pointer to second attr
+ * @returns -1 if attr1 < attr2, 0 if attr1 == attr2 or 1 if attr1 > attr2.
+ */
+static int
+xmlC14NAttrsCompare(const void *data1, const void *data2)
+{
+    const xmlAttr *attr1 = data1;
+    const xmlAttr *attr2 = data2;
+    int ret = 0;
+
+    /*
+     * Simple cases
+     */
+    if (attr1 == attr2)
+        return (0);
+    if (attr1 == NULL)
+        return (-1);
+    if (attr2 == NULL)
+        return (1);
+    if (attr1->ns == attr2->ns) {
+        return (xmlStrcmp(attr1->name, attr2->name));
+    }
+
+    /*
+     * Attributes in the default namespace are first
+     * because the default namespace is not applied to
+     * unqualified attributes
+     */
+    if (attr1->ns == NULL)
+        return (-1);
+    if (attr2->ns == NULL)
+        return (1);
+    if (attr1->ns->prefix == NULL)
+        return (-1);
+    if (attr2->ns->prefix == NULL)
+        return (1);
+
+    ret = xmlStrcmp(attr1->ns->href, attr2->ns->href);
+    if (ret == 0) {
+        ret = xmlStrcmp(attr1->name, attr2->name);
+    }
+    return (ret);
+}
+
+
+/**
+ * Prints out canonical attribute urrent node to the
+ * buffer from C14N context as follows
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * @param data  		the pointer to attr
+ * @param user  		the C14N context
+ * @returns 1 on success or 0 on fail.
+ */
+static int
+xmlC14NPrintAttrs(const void *data, void *user)
+{
+    const xmlAttr *attr = data;
+    xmlC14NCtxPtr ctx = (xmlC14NCtxPtr) user;
+    xmlChar *value;
+    xmlChar *buffer;
+
+    if ((attr == NULL) || (ctx == NULL)) {
+        xmlC14NErrParam(ctx);
+        return (0);
+    }
+
+    xmlOutputBufferWriteString(ctx->buf, " ");
+    if (attr->ns != NULL && xmlStrlen(attr->ns->prefix) > 0) {
+        xmlOutputBufferWriteString(ctx->buf,
+                                   (const char *) attr->ns->prefix);
+        xmlOutputBufferWriteString(ctx->buf, ":");
+    }
+    xmlOutputBufferWriteString(ctx->buf, (const char *) attr->name);
+    xmlOutputBufferWriteString(ctx->buf, "=\"");
+
+    value = xmlNodeListGetString(ctx->doc, attr->children, 1);
+    /* todo: should we log an error if value==NULL ? */
+    if (value != NULL) {
+        buffer = xmlC11NNormalizeAttr(value);
+        xmlFree(value);
+        if (buffer != NULL) {
+            xmlOutputBufferWriteString(ctx->buf, (const char *) buffer);
+            xmlFree(buffer);
+        } else {
+            xmlC14NErrMemory(ctx);
+            return (0);
+        }
+    }
+    xmlOutputBufferWriteString(ctx->buf, "\"");
+    return (1);
+}
+
+/**
+ * Finds an attribute in a hidden parent node.
+ *
+ * @returns a pointer to the attribute node (if found) or NULL otherwise.
+ */
+static xmlAttrPtr
+xmlC14NFindHiddenParentAttr(xmlC14NCtxPtr ctx, xmlNodePtr cur, const xmlChar * name, const xmlChar * ns)
+{
+    xmlAttrPtr res;
+    while((cur != NULL) && (!xmlC14NIsVisible(ctx, cur, cur->parent))) {
+        res = xmlHasNsProp(cur, name, ns);
+        if(res != NULL) {
+            return res;
+        }
+
+        cur = cur->parent;
+    }
+
+    return NULL;
+}
+
+/**
+ * Fixes up the xml:base attribute
+ *
+ * @returns the newly created attribute or NULL
+ */
+static xmlAttrPtr
+xmlC14NFixupBaseAttr(xmlC14NCtxPtr ctx, xmlAttrPtr xml_base_attr)
+{
+    xmlChar * res = NULL;
+    xmlNodePtr cur;
+    xmlAttrPtr attr;
+    xmlChar * tmp_str;
+    xmlChar * tmp_str2;
+    int tmp_str_len;
+
+    if ((ctx == NULL) || (xml_base_attr == NULL) || (xml_base_attr->parent == NULL)) {
+        xmlC14NErrParam(ctx);
+        return (NULL);
+    }
+
+    /* start from current value */
+    res = xmlNodeListGetString(ctx->doc, xml_base_attr->children, 1);
+    if(res == NULL) {
+        xmlC14NErrMemory(ctx);
+        return (NULL);
+    }
+
+    /* go up the stack until we find a node that we rendered already */
+    cur = xml_base_attr->parent->parent;
+    while((cur != NULL) && (!xmlC14NIsVisible(ctx, cur, cur->parent))) {
+        int code;
+
+        attr = xmlHasNsProp(cur, BAD_CAST "base", XML_XML_NAMESPACE);
+        if(attr != NULL) {
+            /* get attr value */
+            tmp_str = xmlNodeListGetString(ctx->doc, attr->children, 1);
+            if(tmp_str == NULL) {
+                xmlFree(res);
+
+                xmlC14NErrMemory(ctx);
+                return (NULL);
+            }
+
+            /* we need to add '/' if our current base uri ends with '..' or '.'
+            to ensure that we are forced to go "up" all the time */
+            tmp_str_len = xmlStrlen(tmp_str);
+            if(tmp_str_len > 1 && tmp_str[tmp_str_len - 2] == '.') {
+                tmp_str2 = xmlStrcat(tmp_str, BAD_CAST "/");
+                if(tmp_str2 == NULL) {
+                    xmlFree(tmp_str);
+                    xmlFree(res);
+
+                    xmlC14NErrMemory(ctx);
+                    return (NULL);
+                }
+
+                tmp_str = tmp_str2;
+            }
+
+            /* build uri */
+            code = xmlBuildURISafe(res, tmp_str, &tmp_str2);
+            if (code != 0) {
+                xmlFree(tmp_str);
+                xmlFree(res);
+
+                if (code < 0)
+                    xmlC14NErrMemory(ctx);
+                else
+                    xmlC14NErr(ctx, cur, XML_ERR_INVALID_URI,
+                               "processing xml:base attribute - "
+                               "can't construct uri");
+                return (NULL);
+            }
+
+            /* cleanup and set the new res */
+            xmlFree(tmp_str);
+            xmlFree(res);
+            res = tmp_str2;
+        }
+
+        /* next */
+        cur = cur->parent;
+    }
+
+    /* check if result uri is empty or not */
+    if((res == NULL) || xmlStrEqual(res, BAD_CAST "")) {
+        xmlFree(res);
+        return (NULL);
+    }
+
+    /* create and return the new attribute node */
+    attr = xmlNewNsProp(NULL, xml_base_attr->ns, BAD_CAST "base", res);
+    if(attr == NULL) {
+        xmlFree(res);
+
+        xmlC14NErrMemory(ctx);
+        return (NULL);
+    }
+
+    /* done */
+    xmlFree(res);
+    return (attr);
+}
+
+/**
+ * Prints out canonical attribute axis of the current node to the
+ * buffer from C14N context as follows
+ *
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Attribute Axis
+ * In lexicographic order (ascending), process each node that
+ * is in the element's attribute axis and in the node-set.
+ *
+ * The processing of an element node E MUST be modified slightly
+ * when an XPath node-set is given as input and the element's
+ * parent is omitted from the node-set.
+ *
+ *
+ * Exclusive XML Canonicalization v 1.0 (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * Canonical XML applied to a document subset requires the search of the
+ * ancestor nodes of each orphan element node for attributes in the xml
+ * namespace, such as xml:lang and xml:space. These are copied into the
+ * element node except if a declaration of the same attribute is already
+ * in the attribute axis of the element (whether or not it is included in
+ * the document subset). This search and copying are omitted from the
+ * Exclusive XML Canonicalization method.
+ *
+ * @param ctx  		the C14N context
+ * @param cur  		the current node
+ * @param parent_visible  	the visibility of the parent node
+ * @returns 0 on success or -1 on fail.
+ */
+static int
+xmlC14NProcessAttrsAxis(xmlC14NCtxPtr ctx, xmlNodePtr cur, int parent_visible)
+{
+    xmlAttrPtr attr;
+    xmlListPtr list;
+    xmlAttrPtr attrs_to_delete = NULL;
+
+    /* special processing for 1.1 spec */
+    xmlAttrPtr xml_base_attr = NULL;
+    xmlAttrPtr xml_lang_attr = NULL;
+    xmlAttrPtr xml_space_attr = NULL;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    /*
+     * Create a sorted list to store element attributes
+     */
+    list = xmlListCreate(NULL, xmlC14NAttrsCompare);
+    if (list == NULL) {
+        xmlC14NErrMemory(ctx);
+        return (-1);
+    }
+
+    switch(ctx->mode) {
+    case XML_C14N_1_0:
+        /* The processing of an element node E MUST be modified slightly when an XPath node-set is
+         * given as input and the element's parent is omitted from the node-set. The method for processing
+         * the attribute axis of an element E in the node-set is enhanced. All element nodes along E's
+         * ancestor axis are examined for nearest occurrences of attributes in the xml namespace, such
+         * as xml:lang and xml:space (whether or not they are in the node-set). From this list of attributes,
+         * remove any that are in E's attribute axis (whether or not they are in the node-set). Then,
+         * lexicographically merge this attribute list with the nodes of E's attribute axis that are in
+         * the node-set. The result of visiting the attribute axis is computed by processing the attribute
+         * nodes in this merged attribute list.
+         */
+
+        /*
+         * Add all visible attributes from current node.
+         */
+        attr = cur->properties;
+        while (attr != NULL) {
+            /* check that attribute is visible */
+            if (xmlC14NIsVisible(ctx, attr, cur)) {
+                xmlListInsert(list, attr);
+            }
+            attr = attr->next;
+        }
+
+        /*
+         * Handle xml attributes
+         */
+        if (parent_visible && (cur->parent != NULL) &&
+            (!xmlC14NIsVisible(ctx, cur->parent, cur->parent->parent)))
+        {
+            xmlNodePtr tmp;
+
+            /*
+             * If XPath node-set is not specified then the parent is always
+             * visible!
+             */
+            tmp = cur->parent;
+            while (tmp != NULL) {
+                attr = tmp->properties;
+                while (attr != NULL) {
+                    if (xmlC14NIsXmlAttr(attr) != 0) {
+                        if (xmlListSearch(list, attr) == NULL) {
+                            xmlListInsert(list, attr);
+                        }
+                    }
+                    attr = attr->next;
+                }
+                tmp = tmp->parent;
+            }
+        }
+
+        /* done */
+        break;
+    case XML_C14N_EXCLUSIVE_1_0:
+        /* attributes in the XML namespace, such as xml:lang and xml:space
+         * are not imported into orphan nodes of the document subset
+         */
+
+        /*
+         * Add all visible attributes from current node.
+         */
+        attr = cur->properties;
+        while (attr != NULL) {
+            /* check that attribute is visible */
+            if (xmlC14NIsVisible(ctx, attr, cur)) {
+                xmlListInsert(list, attr);
+            }
+            attr = attr->next;
+        }
+
+        /* do nothing special for xml attributes */
+        break;
+    case XML_C14N_1_1:
+        /* The processing of an element node E MUST be modified slightly when an XPath node-set is
+         * given as input and some of the element's ancestors are omitted from the node-set.
+         *
+         * Simple inheritable attributes are attributes that have a value that requires at most a simple
+         * redeclaration. This redeclaration is done by supplying a new value in the child axis. The
+         * redeclaration of a simple inheritable attribute A contained in one of E's ancestors is done
+         * by supplying a value to an attribute Ae inside E with the same name. Simple inheritable attributes
+         * are xml:lang and xml:space.
+         *
+         * The method for processing the attribute axis of an element E in the node-set is hence enhanced.
+         * All element nodes along E's ancestor axis are examined for the nearest occurrences of simple
+         * inheritable attributes in the xml namespace, such as xml:lang and xml:space (whether or not they
+         * are in the node-set). From this list of attributes, any simple inheritable attributes that are
+         * already in E's attribute axis (whether or not they are in the node-set) are removed. Then,
+         * lexicographically merge this attribute list with the nodes of E's attribute axis that are in
+         * the node-set. The result of visiting the attribute axis is computed by processing the attribute
+         * nodes in this merged attribute list.
+         *
+         * The xml:id attribute is not a simple inheritable attribute and no processing of these attributes is
+         * performed.
+         *
+         * The xml:base attribute is not a simple inheritable attribute and requires special processing beyond
+         * a simple redeclaration.
+         *
+         * Attributes in the XML namespace other than xml:base, xml:id, xml:lang, and xml:space MUST be processed
+         * as ordinary attributes.
+         */
+
+        /*
+         * Add all visible attributes from current node.
+         */
+        attr = cur->properties;
+        while (attr != NULL) {
+            /* special processing for XML attribute kiks in only when we have invisible parents */
+            if ((!parent_visible) || (xmlC14NIsXmlAttr(attr) == 0)) {
+                /* check that attribute is visible */
+                if (xmlC14NIsVisible(ctx, attr, cur)) {
+                    xmlListInsert(list, attr);
+                }
+            } else {
+                int matched = 0;
+
+                /* check for simple inheritance attributes */
+                if((!matched) && (xml_lang_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "lang")) {
+                    xml_lang_attr = attr;
+                    matched = 1;
+                }
+                if((!matched) && (xml_space_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "space")) {
+                    xml_space_attr = attr;
+                    matched = 1;
+                }
+
+                /* check for base attr */
+                if((!matched) && (xml_base_attr == NULL) && xmlStrEqual(attr->name, BAD_CAST "base")) {
+                    xml_base_attr = attr;
+                    matched = 1;
+                }
+
+                /* otherwise, it is a normal attribute, so just check if it is visible */
+                if((!matched) && xmlC14NIsVisible(ctx, attr, cur)) {
+                    xmlListInsert(list, attr);
+                }
+            }
+
+            /* move to the next one */
+            attr = attr->next;
+        }
+
+        /* special processing for XML attribute kiks in only when we have invisible parents */
+        if ((parent_visible)) {
+
+            /* simple inheritance attributes - copy */
+            if(xml_lang_attr == NULL) {
+                xml_lang_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "lang", XML_XML_NAMESPACE);
+            }
+            if(xml_lang_attr != NULL) {
+                xmlListInsert(list, xml_lang_attr);
+            }
+            if(xml_space_attr == NULL) {
+                xml_space_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "space", XML_XML_NAMESPACE);
+            }
+            if(xml_space_attr != NULL) {
+                xmlListInsert(list, xml_space_attr);
+            }
+
+            /* base uri attribute - fix up */
+            if(xml_base_attr == NULL) {
+                /* if we don't have base uri attribute, check if we have a "hidden" one above */
+                xml_base_attr = xmlC14NFindHiddenParentAttr(ctx, cur->parent, BAD_CAST "base", XML_XML_NAMESPACE);
+            }
+            if(xml_base_attr != NULL) {
+                xml_base_attr = xmlC14NFixupBaseAttr(ctx, xml_base_attr);
+                if(xml_base_attr != NULL) {
+                    xmlListInsert(list, xml_base_attr);
+
+                    /* note that we MUST delete returned attr node ourselves! */
+                    xml_base_attr->next = attrs_to_delete;
+                    attrs_to_delete = xml_base_attr;
+                }
+            }
+        }
+
+        /* done */
+        break;
+    }
+
+    /*
+     * print out all elements from list
+     */
+    xmlListWalk(list, xmlC14NPrintAttrs, (void *) ctx);
+
+    /*
+     * Cleanup
+     */
+    xmlFreePropList(attrs_to_delete);
+    xmlListDelete(list);
+    return (0);
+}
+
+/**
+ * Checks that current element node has no relative namespaces defined
+ *
+ * @param ctx  		the C14N context
+ * @param cur  		the current element node
+ * @returns 0 if the node has no relative namespaces or -1 otherwise.
+ */
+static int
+xmlC14NCheckForRelativeNamespaces(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    xmlNsPtr ns;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    ns = cur->nsDef;
+    while (ns != NULL) {
+        if (xmlStrlen(ns->href) > 0) {
+            xmlURIPtr uri;
+            int code;
+
+            code = xmlParseURISafe((const char *) ns->href, &uri);
+            if (uri == NULL) {
+                if (code < 0)
+                    xmlC14NErrMemory(ctx);
+                else
+                    xmlC14NErr(ctx, cur, XML_ERR_INVALID_URI,
+                               "parsing namespace uri");
+                return (-1);
+            }
+            if (xmlStrlen((const xmlChar *) uri->scheme) == 0) {
+                xmlC14NErrRelativeNamespace(ctx, uri->scheme);
+                xmlFreeURI(uri);
+                return (-1);
+            }
+            xmlFreeURI(uri);
+        }
+        ns = ns->next;
+    }
+    return (0);
+}
+
+/**
+ * Canonical XML v 1.0 (http://www.w3.org/TR/xml-c14n)
+ *
+ * Element Nodes
+ * If the element is not in the node-set, then the result is obtained
+ * by processing the namespace axis, then the attribute axis, then
+ * processing the child nodes of the element that are in the node-set
+ * (in document order). If the element is in the node-set, then the result
+ * is an open angle bracket (<), the element QName, the result of
+ * processing the namespace axis, the result of processing the attribute
+ * axis, a close angle bracket (>), the result of processing the child
+ * nodes of the element that are in the node-set (in document order), an
+ * open angle bracket, a forward slash (/), the element QName, and a close
+ * angle bracket.
+ *
+ * @param ctx  		the pointer to C14N context object
+ * @param cur  		the node to process
+ * @param visible  		this node is visible
+ * @returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessElementNode(xmlC14NCtxPtr ctx, xmlNodePtr cur, int visible)
+{
+    int ret;
+    xmlC14NVisibleNsStack state;
+    int parent_is_doc = 0;
+
+    if ((ctx == NULL) || (cur == NULL) || (cur->type != XML_ELEMENT_NODE)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    /*
+     * Check relative relative namespaces:
+     * implementations of XML canonicalization MUST report an operation
+     * failure on documents containing relative namespace URIs.
+     */
+    if (xmlC14NCheckForRelativeNamespaces(ctx, cur) < 0)
+        return (-1);
+
+    /*
+     * Save ns_rendered stack position
+     */
+    memset(&state, 0, sizeof(state));
+    xmlC14NVisibleNsStackSave(ctx->ns_rendered, &state);
+
+    if (visible) {
+        if (ctx->parent_is_doc) {
+	    /* save this flag into the stack */
+	    parent_is_doc = ctx->parent_is_doc;
+	    ctx->parent_is_doc = 0;
+            ctx->pos = XMLC14N_INSIDE_DOCUMENT_ELEMENT;
+        }
+        xmlOutputBufferWriteString(ctx->buf, "<");
+
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
+    }
+
+    if (!xmlC14NIsExclusive(ctx)) {
+        ret = xmlC14NProcessNamespacesAxis(ctx, cur, visible);
+    } else {
+        ret = xmlExcC14NProcessNamespacesAxis(ctx, cur, visible);
+    }
+    if (ret < 0)
+        return (-1);
+    /* todo: shouldn't this go to "visible only"? */
+    if(visible) {
+	xmlC14NVisibleNsStackShift(ctx->ns_rendered);
+    }
+
+    ret = xmlC14NProcessAttrsAxis(ctx, cur, visible);
+    if (ret < 0)
+	return (-1);
+
+    if (visible) {
+        xmlOutputBufferWriteString(ctx->buf, ">");
+    }
+    if (cur->children != NULL) {
+        ret = xmlC14NProcessNodeList(ctx, cur->children);
+        if (ret < 0)
+            return (-1);
+    }
+    if (visible) {
+        xmlOutputBufferWriteString(ctx->buf, "</");
+        if ((cur->ns != NULL) && (xmlStrlen(cur->ns->prefix) > 0)) {
+            xmlOutputBufferWriteString(ctx->buf,
+                                       (const char *) cur->ns->prefix);
+            xmlOutputBufferWriteString(ctx->buf, ":");
+        }
+        xmlOutputBufferWriteString(ctx->buf, (const char *) cur->name);
+        xmlOutputBufferWriteString(ctx->buf, ">");
+        if (parent_is_doc) {
+	    /* restore this flag from the stack for next node */
+            ctx->parent_is_doc = parent_is_doc;
+	    ctx->pos = XMLC14N_AFTER_DOCUMENT_ELEMENT;
+        }
+    }
+
+    /*
+     * Restore ns_rendered stack position
+     */
+    xmlC14NVisibleNsStackRestore(ctx->ns_rendered, &state);
+    return (0);
+}
+
+/**
+ * Processes the given node
+ *
+ * @param ctx  		the pointer to C14N context object
+ * @param cur  		the node to process
+ * @returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessNode(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    int ret = 0;
+    int visible;
+
+    if ((ctx == NULL) || (cur == NULL)) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    visible = xmlC14NIsVisible(ctx, cur, cur->parent);
+    switch (cur->type) {
+        case XML_ELEMENT_NODE:
+            ret = xmlC14NProcessElementNode(ctx, cur, visible);
+            break;
+        case XML_CDATA_SECTION_NODE:
+        case XML_TEXT_NODE:
+            /*
+             * Text Nodes
+             * the string value, except all ampersands are replaced
+             * by &amp;, all open angle brackets (<) are replaced by &lt;, all closing
+             * angle brackets (>) are replaced by &gt;, and all #xD characters are
+             * replaced by &#xD;.
+             */
+            /* cdata sections are processed as text nodes */
+            /* todo: verify that cdata sections are included in XPath nodes set */
+            if ((visible) && (cur->content != NULL)) {
+                xmlChar *buffer;
+
+                buffer = xmlC11NNormalizeText(cur->content);
+                if (buffer != NULL) {
+                    xmlOutputBufferWriteString(ctx->buf,
+                                               (const char *) buffer);
+                    xmlFree(buffer);
+                } else {
+                    xmlC14NErrMemory(ctx);
+                    return (-1);
+                }
+            }
+            break;
+        case XML_PI_NODE:
+            /*
+             * Processing Instruction (PI) Nodes-
+             * The opening PI symbol (<?), the PI target name of the node,
+             * a leading space and the string value if it is not empty, and
+             * the closing PI symbol (?>). If the string value is empty,
+             * then the leading space is not added. Also, a trailing #xA is
+             * rendered after the closing PI symbol for PI children of the
+             * root node with a lesser document order than the document
+             * element, and a leading #xA is rendered before the opening PI
+             * symbol of PI children of the root node with a greater document
+             * order than the document element.
+             */
+            if (visible) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<?");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<?");
+                }
+
+                xmlOutputBufferWriteString(ctx->buf,
+                                           (const char *) cur->name);
+                if ((cur->content != NULL) && (*(cur->content) != '\0')) {
+                    xmlChar *buffer;
+
+                    xmlOutputBufferWriteString(ctx->buf, " ");
+
+                    /* todo: do we need to normalize pi? */
+                    buffer = xmlC11NNormalizePI(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
+                        xmlC14NErrMemory(ctx);
+                        return (-1);
+                    }
+                }
+
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "?>\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "?>");
+                }
+            }
+            break;
+        case XML_COMMENT_NODE:
+            /*
+             * Comment Nodes
+             * Nothing if generating canonical XML without  comments. For
+             * canonical XML with comments, generate the opening comment
+             * symbol (<!--), the string value of the node, and the
+             * closing comment symbol (-->). Also, a trailing #xA is rendered
+             * after the closing comment symbol for comment children of the
+             * root node with a lesser document order than the document
+             * element, and a leading #xA is rendered before the opening
+             * comment symbol of comment children of the root node with a
+             * greater document order than the document element. (Comment
+             * children of the root node represent comments outside of the
+             * top-level document element and outside of the document type
+             * declaration).
+             */
+            if (visible && ctx->with_comments) {
+                if (ctx->pos == XMLC14N_AFTER_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "\x0A<!--");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "<!--");
+                }
+
+                if (cur->content != NULL) {
+                    xmlChar *buffer;
+
+                    /* todo: do we need to normalize comment? */
+                    buffer = xmlC11NNormalizeComment(cur->content);
+                    if (buffer != NULL) {
+                        xmlOutputBufferWriteString(ctx->buf,
+                                                   (const char *) buffer);
+                        xmlFree(buffer);
+                    } else {
+                        xmlC14NErrMemory(ctx);
+                        return (-1);
+                    }
+                }
+
+                if (ctx->pos == XMLC14N_BEFORE_DOCUMENT_ELEMENT) {
+                    xmlOutputBufferWriteString(ctx->buf, "-->\x0A");
+                } else {
+                    xmlOutputBufferWriteString(ctx->buf, "-->");
+                }
+            }
+            break;
+        case XML_DOCUMENT_NODE:
+        case XML_DOCUMENT_FRAG_NODE:   /* should be processed as document? */
+#ifdef LIBXML_HTML_ENABLED
+        case XML_HTML_DOCUMENT_NODE:   /* should be processed as document? */
+#endif
+            if (cur->children != NULL) {
+                ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
+                ctx->parent_is_doc = 1;
+                ret = xmlC14NProcessNodeList(ctx, cur->children);
+            }
+            break;
+
+        case XML_ATTRIBUTE_NODE:
+            xmlC14NErrInvalidNode(ctx, "XML_ATTRIBUTE_NODE", "processing node");
+            return (-1);
+        case XML_NAMESPACE_DECL:
+            xmlC14NErrInvalidNode(ctx, "XML_NAMESPACE_DECL", "processing node");
+            return (-1);
+        case XML_ENTITY_REF_NODE:
+            xmlC14NErrInvalidNode(ctx, "XML_ENTITY_REF_NODE", "processing node");
+            return (-1);
+        case XML_ENTITY_NODE:
+            xmlC14NErrInvalidNode(ctx, "XML_ENTITY_NODE", "processing node");
+            return (-1);
+
+        case XML_DOCUMENT_TYPE_NODE:
+        case XML_NOTATION_NODE:
+        case XML_DTD_NODE:
+        case XML_ELEMENT_DECL:
+        case XML_ATTRIBUTE_DECL:
+        case XML_ENTITY_DECL:
+#ifdef LIBXML_XINCLUDE_ENABLED
+        case XML_XINCLUDE_START:
+        case XML_XINCLUDE_END:
+#endif
+            /*
+             * should be ignored according to "W3C Canonical XML"
+             */
+            break;
+        default:
+            xmlC14NErrUnknownNode(ctx, cur->type, "processing node");
+            return (-1);
+    }
+
+    return (ret);
+}
+
+/**
+ * Processes all nodes in the row starting from cur.
+ *
+ * @param ctx  		the pointer to C14N context object
+ * @param cur  		the node to start from
+ * @returns non-negative value on success or negative value on fail
+ */
+static int
+xmlC14NProcessNodeList(xmlC14NCtxPtr ctx, xmlNodePtr cur)
+{
+    int ret;
+
+    if (ctx == NULL) {
+        xmlC14NErrParam(ctx);
+        return (-1);
+    }
+
+    for (ret = 0; cur != NULL && ret >= 0; cur = cur->next) {
+        ret = xmlC14NProcessNode(ctx, cur);
+    }
+    return (ret);
+}
+
+
+/**
+ * Cleanups the C14N context object.
+ *
+ * @param ctx  the pointer to C14N context object
+ */
+
+static void
+xmlC14NFreeCtx(xmlC14NCtxPtr ctx)
+{
+    if (ctx == NULL) {
+        xmlC14NErrParam(ctx);
+        return;
+    }
+
+    if (ctx->ns_rendered != NULL) {
+        xmlC14NVisibleNsStackDestroy(ctx->ns_rendered);
+    }
+    xmlFree(ctx);
+}
+
+/**
+ * Creates new C14N context object to store C14N parameters.
+ *
+ * @param doc  		the XML document for canonization
+ * @param is_visible_callback  the function to use to determine is node visible
+ *			or not
+ * @param user_data  		the first parameter for `is_visible_callback` function
+ *			(in most cases, it is nodes set)
+ * @param mode  the c14n mode (see `xmlC14NMode`)
+ * @param inclusive_ns_prefixes  the list of inclusive namespace prefixes
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for `
+ *			canonicalization)
+ * @param with_comments  	include comments in the result (!=0) or not (==0)
+ * @param buf  		the output buffer to store canonical XML; this
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ * @returns pointer to newly created object (success) or NULL (fail)
+ */
+static xmlC14NCtxPtr
+xmlC14NNewCtx(xmlDocPtr doc,
+	      xmlC14NIsVisibleCallback is_visible_callback, void* user_data,
+              xmlC14NMode mode, xmlChar ** inclusive_ns_prefixes,
+              int with_comments, xmlOutputBufferPtr buf)
+{
+    xmlC14NCtxPtr ctx = NULL;
+
+    if ((doc == NULL) || (buf == NULL)) {
+        xmlC14NErrParam(ctx);
+        return (NULL);
+    }
+
+    /*
+     *  Validate the encoding output buffer encoding
+     */
+    if (buf->encoder != NULL) {
+        xmlC14NErr(ctx, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
+"xmlC14NNewCtx: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (NULL);
+    }
+
+    /*
+     * Allocate a new xmlC14NCtx and fill the fields.
+     */
+    ctx = (xmlC14NCtxPtr) xmlMalloc(sizeof(xmlC14NCtx));
+    if (ctx == NULL) {
+	xmlC14NErrMemory(ctx);
+        return (NULL);
+    }
+    memset(ctx, 0, sizeof(xmlC14NCtx));
+
+    /*
+     * initialize C14N context
+     */
+    ctx->doc = doc;
+    ctx->with_comments = with_comments;
+    ctx->is_visible_callback = is_visible_callback;
+    ctx->user_data = user_data;
+    ctx->buf = buf;
+    ctx->parent_is_doc = 1;
+    ctx->pos = XMLC14N_BEFORE_DOCUMENT_ELEMENT;
+    ctx->ns_rendered = xmlC14NVisibleNsStackCreate();
+
+    if(ctx->ns_rendered == NULL) {
+        xmlC14NErrMemory(ctx);
+	xmlC14NFreeCtx(ctx);
+        return (NULL);
+    }
+
+    /*
+     * Set "mode" flag and remember list of inclusive prefixes
+     * for exclusive c14n
+     */
+    ctx->mode = mode;
+    if(xmlC14NIsExclusive(ctx)) {
+        ctx->inclusive_ns_prefixes = inclusive_ns_prefixes;
+    }
+
+    return (ctx);
+}
+
+/**
+ * Dumps the canonized image of given XML document into the provided buffer.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * @param doc  		the XML document for canonization
+ * @param is_visible_callback  the function to use to determine is node visible
+ *			or not
+ * @param user_data  		the first parameter for `is_visible_callback` function
+ *			(in most cases, it is nodes set)
+ * @param mode  	the c14n mode (see `xmlC14NMode`)
+ * @param inclusive_ns_prefixes  the list of inclusive namespace prefixes
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive
+ *			canonicalization, ignored otherwise)
+ * @param with_comments  	include comments in the result (!=0) or not (==0)
+ * @param buf  		the output buffer to store canonical XML; this
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ * @returns non-negative value on success or a negative value on fail
+ */
+int
+xmlC14NExecute(xmlDoc *doc, xmlC14NIsVisibleCallback is_visible_callback,
+	 void* user_data, int mode, xmlChar **inclusive_ns_prefixes,
+	 int with_comments, xmlOutputBuffer *buf) {
+
+    xmlC14NCtxPtr ctx;
+    xmlC14NMode c14n_mode = XML_C14N_1_0;
+    int ret;
+
+    if ((buf == NULL) || (doc == NULL)) {
+        xmlC14NErrParam(NULL);
+        return (-1);
+    }
+
+    /* for backward compatibility, we have to have "mode" as "int"
+       and here we check that user gives valid value */
+    switch(mode) {
+    case XML_C14N_1_0:
+    case XML_C14N_EXCLUSIVE_1_0:
+    case XML_C14N_1_1:
+         c14n_mode = (xmlC14NMode)mode;
+         break;
+    default:
+        xmlC14NErrParam(NULL);
+        return (-1);
+    }
+
+    /*
+     *  Validate the encoding output buffer encoding
+     */
+    if (buf->encoder != NULL) {
+        xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_REQUIRES_UTF8,
+"xmlC14NExecute: output buffer encoder != NULL but C14N requires UTF8 output\n");
+        return (-1);
+    }
+
+    ctx = xmlC14NNewCtx(doc, is_visible_callback, user_data,
+	            c14n_mode, inclusive_ns_prefixes,
+                    with_comments, buf);
+    if (ctx == NULL) {
+        xmlC14NErr(NULL, (xmlNodePtr) doc, XML_C14N_CREATE_CTXT,
+		   "xmlC14NExecute: unable to create C14N context\n");
+        return (-1);
+    }
+
+
+
+    /*
+     * Root Node
+     * The root node is the parent of the top-level document element. The
+     * result of processing each of its child nodes that is in the node-set
+     * in document order. The root node does not generate a byte order mark,
+     * XML declaration, nor anything from within the document type
+     * declaration.
+     */
+    if (doc->children != NULL) {
+        ret = xmlC14NProcessNodeList(ctx, doc->children);
+        if (ret < 0) {
+            xmlC14NFreeCtx(ctx);
+            return (-1);
+        }
+    }
+
+    /*
+     * Flush buffer to get number of bytes written
+     */
+    ret = xmlOutputBufferFlush(buf);
+    if (ret < 0) {
+        xmlC14NErr(ctx, NULL, buf->error, "flushing output buffer");
+        xmlC14NFreeCtx(ctx);
+        return (-1);
+    }
+
+    /*
+     * Cleanup
+     */
+    xmlC14NFreeCtx(ctx);
+    return (ret);
+}
+
+/**
+ * Dumps the canonized image of given XML document into the provided buffer.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * @param doc  		the XML document for canonization
+ * @param nodes  		the nodes set to be included in the canonized image
+ *		or NULL if all document nodes should be included
+ * @param mode  		the c14n mode (see `xmlC14NMode`)
+ * @param inclusive_ns_prefixes  the list of inclusive namespace prefixes
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive
+ *			canonicalization, ignored otherwise)
+ * @param with_comments  	include comments in the result (!=0) or not (==0)
+ * @param buf  		the output buffer to store canonical XML; this
+ *			buffer MUST have encoder==NULL because C14N requires
+ *			UTF-8 output
+ * @returns non-negative value on success or a negative value on fail
+ */
+int
+xmlC14NDocSaveTo(xmlDoc *doc, xmlNodeSet *nodes,
+                 int mode, xmlChar ** inclusive_ns_prefixes,
+                 int with_comments, xmlOutputBuffer *buf) {
+    return(xmlC14NExecute(doc,
+			xmlC14NIsNodeInNodeset,
+			nodes,
+			mode,
+			inclusive_ns_prefixes,
+			with_comments,
+			buf));
+}
+
+
+/**
+ * Dumps the canonized image of given XML document into memory.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * @param doc  		the XML document for canonization
+ * @param nodes  		the nodes set to be included in the canonized image
+ *		or NULL if all document nodes should be included
+ * @param mode  		the c14n mode (see `xmlC14NMode`)
+ * @param inclusive_ns_prefixes  the list of inclusive namespace prefixes
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive
+ *			canonicalization, ignored otherwise)
+ * @param with_comments  	include comments in the result (!=0) or not (==0)
+ * @param doc_txt_ptr  	the memory pointer for allocated canonical XML text;
+ *			the caller of this functions is responsible for calling
+ *			xmlFree() to free allocated memory
+ * @returns the number of bytes written on success or a negative value on fail
+ */
+int
+xmlC14NDocDumpMemory(xmlDoc *doc, xmlNodeSet *nodes,
+                     int mode, xmlChar ** inclusive_ns_prefixes,
+                     int with_comments, xmlChar ** doc_txt_ptr)
+{
+    int ret;
+    xmlOutputBufferPtr buf;
+
+    if (doc_txt_ptr == NULL) {
+        xmlC14NErrParam(NULL);
+        return (-1);
+    }
+
+    *doc_txt_ptr = NULL;
+
+    /*
+     * create memory buffer with UTF8 (default) encoding
+     */
+    buf = xmlAllocOutputBuffer(NULL);
+    if (buf == NULL) {
+        xmlC14NErrMemory(NULL);
+        return (-1);
+    }
+
+    /*
+     * canonize document and write to buffer
+     */
+    ret = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
+    }
+
+    ret = xmlBufUse(buf->buffer);
+    if (ret >= 0) {
+        *doc_txt_ptr = xmlStrndup(xmlBufContent(buf->buffer), ret);
+    }
+    (void) xmlOutputBufferClose(buf);
+
+    if ((*doc_txt_ptr == NULL) && (ret >= 0)) {
+        xmlC14NErrMemory(NULL);
+        return (-1);
+    }
+    return (ret);
+}
+
+/**
+ * Dumps the canonized image of given XML document into the file.
+ * For details see "Canonical XML" (http://www.w3.org/TR/xml-c14n) or
+ * "Exclusive XML Canonicalization" (http://www.w3.org/TR/xml-exc-c14n)
+ *
+ * @param doc  		the XML document for canonization
+ * @param nodes  		the nodes set to be included in the canonized image
+ *		or NULL if all document nodes should be included
+ * @param mode  		the c14n mode (see `xmlC14NMode`)
+ * @param inclusive_ns_prefixes  the list of inclusive namespace prefixes
+ *			ended with a NULL or NULL if there is no
+ *			inclusive namespaces (only for exclusive
+ *			canonicalization, ignored otherwise)
+ * @param with_comments  	include comments in the result (!=0) or not (==0)
+ * @param filename  		the filename to store canonical XML image
+ * @param compression  	the compression level (zlib required):
+ *				-1 - libxml default,
+ *				 0 - uncompressed,
+ *				>0 - compression level
+ * @returns the number of bytes written success or a negative value on fail
+ */
+int
+xmlC14NDocSave(xmlDoc *doc, xmlNodeSet *nodes,
+               int mode, xmlChar ** inclusive_ns_prefixes,
+               int with_comments, const char *filename, int compression)
+{
+    xmlOutputBufferPtr buf;
+    int ret;
+
+    if (filename == NULL) {
+        xmlC14NErrParam(NULL);
+        return (-1);
+    }
+#ifdef LIBXML_ZLIB_ENABLED
+    if (compression < 0)
+        compression = xmlGetCompressMode();
+#endif
+
+    /*
+     * save the content to a temp buffer, use default UTF8 encoding.
+     */
+    buf = xmlOutputBufferCreateFilename(filename, NULL, compression);
+    if (buf == NULL) {
+        xmlC14NErr(NULL, NULL, XML_IO_UNKNOWN, "creating temporary filename");
+        return (-1);
+    }
+
+    /*
+     * canonize document and write to buffer
+     */
+    ret = xmlC14NDocSaveTo(doc, nodes, mode, inclusive_ns_prefixes,
+                           with_comments, buf);
+    if (ret < 0) {
+        (void) xmlOutputBufferClose(buf);
+        return (-1);
+    }
+
+    /*
+     * get the numbers of bytes written
+     */
+    ret = xmlOutputBufferClose(buf);
+    return (ret);
+}
+
+/**
+ * Converts a string to a canonical (normalized) format. The code is stolen
+ * from xmlEscapeText. Added normalization of `\x09`, `\x0a`,
+ * `\x0A` and the `mode` parameter.
+ *
+ * @param input  		the input string
+ * @param mode  		the normalization mode (attribute, comment, PI or text)
+ * @returns a normalized string (caller is responsible for calling #xmlFree)
+ * or NULL if an error occurs
+ */
+static xmlChar *
+xmlC11NNormalizeString(const xmlChar * input,
+                       xmlC14NNormalizationMode mode)
+{
+    const xmlChar *cur = input;
+    xmlChar *buffer = NULL;
+    xmlChar *out = NULL;
+    int buffer_size = 0;
+
+    if (input == NULL)
+        return (NULL);
+
+    /*
+     * allocate an translation buffer.
+     */
+    buffer_size = 1000;
+    buffer = xmlMalloc(buffer_size);
+    if (buffer == NULL)
+        return (NULL);
+    out = buffer;
+
+    while (*cur != '\0') {
+        if ((out - buffer) > (buffer_size - 10)) {
+            xmlChar *tmp;
+            int indx = out - buffer;
+            int newSize;
+
+            newSize = xmlGrowCapacity(buffer_size, 1, 1, XML_MAX_ITEMS);
+            if (newSize < 0) {
+                xmlFree(buffer);
+                return(NULL);
+            }
+            tmp = xmlRealloc(buffer, newSize);
+            if (tmp == NULL) {
+                xmlFree(buffer);
+                return(NULL);
+            }
+            buffer = tmp;
+            buffer_size = newSize;
+            out = &buffer[indx];
+        }
+
+        if ((*cur == '<') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                              (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'l';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '>') && (mode == XMLC14N_NORMALIZE_TEXT)) {
+            *out++ = '&';
+            *out++ = 'g';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '&') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                     (mode == XMLC14N_NORMALIZE_TEXT))) {
+            *out++ = '&';
+            *out++ = 'a';
+            *out++ = 'm';
+            *out++ = 'p';
+            *out++ = ';';
+        } else if ((*cur == '"') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = 'q';
+            *out++ = 'u';
+            *out++ = 'o';
+            *out++ = 't';
+            *out++ = ';';
+        } else if ((*cur == '\x09') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = '9';
+            *out++ = ';';
+        } else if ((*cur == '\x0A') && (mode == XMLC14N_NORMALIZE_ATTR)) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'A';
+            *out++ = ';';
+        } else if ((*cur == '\x0D') && ((mode == XMLC14N_NORMALIZE_ATTR) ||
+                                        (mode == XMLC14N_NORMALIZE_TEXT) ||
+                                        (mode == XMLC14N_NORMALIZE_COMMENT) ||
+					(mode == XMLC14N_NORMALIZE_PI))) {
+            *out++ = '&';
+            *out++ = '#';
+            *out++ = 'x';
+            *out++ = 'D';
+            *out++ = ';';
+        } else {
+            /*
+             * Works because on UTF-8, all extended sequences cannot
+             * result in bytes in the ASCII range.
+             */
+            *out++ = *cur;
+        }
+        cur++;
+    }
+    *out = 0;
+    return (buffer);
+}
+
+#endif /* LIBXML_C14N_ENABLED */

chvalid.c

@@ -0,0 +1,174 @@
+/*
+ * chvalid.c:	this module implements the character range
+ *		validation APIs
+ */
+
+#define IN_LIBXML
+#include "libxml.h"
+#include <libxml/chvalid.h>
+
+#include <stddef.h>
+
+/*
+ * The initial tables ({func_name}_tab) are used to validate whether a
+ * single-byte character is within the specified group.  Each table
+ * contains 256 bytes, with each byte representing one of the 256
+ * possible characters.  If the table byte is set, the character is
+ * allowed.
+ *
+ */
+
+#include "codegen/ranges.inc"
+
+/**
+ * Does a binary search of the range table to determine if char
+ * is valid
+ *
+ * @param val  character to be validated
+ * @param rptr  pointer to range to be used to validate
+ * @returns true if character valid, false otherwise
+ */
+int
+xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) {
+    int low, high, mid;
+    const xmlChSRange *sptr;
+    const xmlChLRange *lptr;
+
+    if (rptr == NULL) return(0);
+    if (val < 0x10000) {	/* is val in 'short' or 'long'  array? */
+	if (rptr->nbShortRange == 0)
+	    return 0;
+	low = 0;
+	high = rptr->nbShortRange - 1;
+	sptr = rptr->shortRange;
+	while (low <= high) {
+	    mid = (low + high) / 2;
+	    if ((unsigned short) val < sptr[mid].low) {
+		high = mid - 1;
+	    } else {
+		if ((unsigned short) val > sptr[mid].high) {
+		    low = mid + 1;
+		} else {
+		    return 1;
+		}
+	    }
+	}
+    } else {
+	if (rptr->nbLongRange == 0) {
+	    return 0;
+	}
+	low = 0;
+	high = rptr->nbLongRange - 1;
+	lptr = rptr->longRange;
+	while (low <= high) {
+	    mid = (low + high) / 2;
+	    if (val < lptr[mid].low) {
+		high = mid - 1;
+	    } else {
+		if (val > lptr[mid].high) {
+		    low = mid + 1;
+		} else {
+		    return 1;
+		}
+	    }
+	}
+    }
+    return 0;
+}
+
+
+/**
+ * @deprecated Use #xmlIsBaseChar_ch or #xmlIsBaseCharQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsBaseChar(unsigned int ch) {
+    return(xmlIsBaseCharQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsBlank_ch or #xmlIsBlankQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsBlank(unsigned int ch) {
+    return(xmlIsBlankQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsChar_ch or #xmlIsCharQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsChar(unsigned int ch) {
+    return(xmlIsCharQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsCombiningQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsCombining(unsigned int ch) {
+    return(xmlIsCombiningQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsDigit_ch or #xmlIsDigitQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsDigit(unsigned int ch) {
+    return(xmlIsDigitQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsExtender_ch or #xmlIsExtenderQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsExtender(unsigned int ch) {
+    return(xmlIsExtenderQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsIdeographicQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsIdeographic(unsigned int ch) {
+    return(xmlIsIdeographicQ(ch));
+}
+
+
+/**
+ * @deprecated Use #xmlIsPubidChar_ch or #xmlIsPubidCharQ.
+ *
+ * @param ch  character to validate
+ * @returns true if argument valid, false otherwise
+ */
+int
+xmlIsPubidChar(unsigned int ch) {
+    return(xmlIsPubidCharQ(ch));
+}
+

codegen/charset.inc

@@ -0,0 +1,1223 @@
+/*
+ * Lookup tables for transcoding of 8-bit character sets.
+ *
+ * Generated with tools/genTranscode.py.
+ */
+
+static const unsigned short xmlunicodetable_windows_1252 [128] = {
+    0x20ac, 0x0081, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+    0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008d, 0x017d, 0x008f,
+    0x0090, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+    0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x009d, 0x017e, 0x0178,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+};
+
+static const unsigned char xmltranscodetable_windows_1252 [48 + 10 * 64] = {
+    0x00, 0x00, 0x03, 0x09, 0x00, 0x07, 0x05, 0x00,
+    0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x02, 0x00, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x8d, 0x00, 0x8f,
+    0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x9d, 0x00, 0x00,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x96, 0x97, 0x00, 0x00, 0x00,
+    0x91, 0x92, 0x82, 0x00, 0x93, 0x94, 0x84, 0x00,
+    0x86, 0x87, 0x95, 0x00, 0x00, 0x00, 0x85, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x8b, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x88, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x98, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x8c, 0x9c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x8a, 0x9a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x9f, 0x00, 0x00, 0x00, 0x00, 0x8e, 0x9e, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x99, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+};
+
+#if !defined(LIBXML_ICONV_ENABLED) && \
+    !defined(LIBXML_ICU_ENABLED) && \
+    defined(LIBXML_ISO8859X_ENABLED)
+
+static const unsigned short xmlunicodetable_ISO8859_2 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7,
+    0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
+    0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7,
+    0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
+    0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+    0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
+    0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+    0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+    0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
+    0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_2 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x05, 0x02, 0x04, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0xa7,
+    0xa8, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
+    0xb0, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00,
+    0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xc3, 0xe3, 0xa1, 0xb1, 0xc6, 0xe6,
+    0x00, 0x00, 0x00, 0x00, 0xc8, 0xe8, 0xcf, 0xef,
+    0xd0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xca, 0xea, 0xcc, 0xec, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xc5, 0xe5, 0x00, 0x00, 0xa5, 0xb5, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa2, 0xff, 0x00, 0xb2, 0x00, 0xbd, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xa3, 0xb3, 0xd1, 0xf1, 0x00, 0x00, 0xd2,
+    0xf2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xd5, 0xf5, 0x00, 0x00, 0xc0, 0xe0, 0x00, 0x00,
+    0xd8, 0xf8, 0xa6, 0xb6, 0x00, 0x00, 0xaa, 0xba,
+    0xa9, 0xb9, 0xde, 0xfe, 0xab, 0xbb, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd9, 0xf9,
+    0xdb, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xac, 0xbc, 0xaf, 0xbf, 0xae, 0xbe, 0x00,
+    0x00, 0xc1, 0xc2, 0x00, 0xc4, 0x00, 0x00, 0xc7,
+    0x00, 0xc9, 0x00, 0xcb, 0x00, 0xcd, 0xce, 0x00,
+    0x00, 0x00, 0x00, 0xd3, 0xd4, 0x00, 0xd6, 0xd7,
+    0x00, 0x00, 0xda, 0x00, 0xdc, 0xdd, 0x00, 0xdf,
+    0x00, 0xe1, 0xe2, 0x00, 0xe4, 0x00, 0x00, 0xe7,
+    0x00, 0xe9, 0x00, 0xeb, 0x00, 0xed, 0xee, 0x00,
+    0x00, 0x00, 0x00, 0xf3, 0xf4, 0x00, 0xf6, 0xf7,
+    0x00, 0x00, 0xfa, 0x00, 0xfc, 0xfd, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_3 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0x0000, 0x0124, 0x00a7,
+    0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0x0000, 0x017b,
+    0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7,
+    0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0x0000, 0x017c,
+    0x00c0, 0x00c1, 0x00c2, 0x0000, 0x00c4, 0x010a, 0x0108, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0000, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7,
+    0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x0000, 0x00e4, 0x010b, 0x0109, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0000, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7,
+    0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_3 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x05, 0x02, 0x04, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0xa3, 0xa4, 0x00, 0x00, 0xa7,
+    0xa8, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
+    0xb0, 0x00, 0xb2, 0xb3, 0xb4, 0xb5, 0x00, 0xb7,
+    0xb8, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc6, 0xe6, 0xc5, 0xe5, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xd8, 0xf8, 0xab, 0xbb,
+    0xd5, 0xf5, 0x00, 0x00, 0xa6, 0xb6, 0xa1, 0xb1,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa9, 0xb9, 0x00, 0x00, 0xac, 0xbc, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa2, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xde, 0xfe, 0xaa, 0xba,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xdd, 0xfd, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xaf, 0xbf, 0x00, 0x00, 0x00,
+    0xc0, 0xc1, 0xc2, 0x00, 0xc4, 0x00, 0x00, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0x00, 0xd1, 0xd2, 0xd3, 0xd4, 0x00, 0xd6, 0xd7,
+    0x00, 0xd9, 0xda, 0xdb, 0xdc, 0x00, 0x00, 0xdf,
+    0xe0, 0xe1, 0xe2, 0x00, 0xe4, 0x00, 0x00, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0x00, 0xf1, 0xf2, 0xf3, 0xf4, 0x00, 0xf6, 0xf7,
+    0x00, 0xf9, 0xfa, 0xfb, 0xfc, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_4 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7,
+    0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af,
+    0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7,
+    0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b,
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a,
+    0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df,
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b,
+    0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_4 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x05, 0x02, 0x03, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0xa7,
+    0xa8, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0xaf,
+    0xb0, 0x00, 0x00, 0x00, 0xb4, 0x00, 0x00, 0x00,
+    0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0xe0, 0x00, 0x00, 0xa1, 0xb1, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xc8, 0xe8, 0x00, 0x00,
+    0xd0, 0xf0, 0xaa, 0xba, 0x00, 0x00, 0xcc, 0xec,
+    0xca, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xab, 0xbb, 0x00, 0x00, 0x00, 0x00,
+    0xa5, 0xb5, 0xcf, 0xef, 0x00, 0x00, 0xc7, 0xe7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd3, 0xf3,
+    0xa2, 0x00, 0x00, 0xa6, 0xb6, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xd1, 0xf1, 0x00,
+    0x00, 0x00, 0xbd, 0xbf, 0xd2, 0xf2, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa3, 0xb3,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa9, 0xb9, 0x00, 0x00, 0x00, 0x00, 0xac, 0xbc,
+    0xdd, 0xfd, 0xde, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xd9, 0xf9, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xae, 0xbe, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0xb2, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0x00,
+    0x00, 0xc9, 0x00, 0xcb, 0x00, 0xcd, 0xce, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0x00, 0xda, 0xdb, 0xdc, 0x00, 0x00, 0xdf,
+    0x00, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0x00,
+    0x00, 0xe9, 0x00, 0xeb, 0x00, 0xed, 0xee, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0x00, 0xfa, 0xfb, 0xfc, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_5 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
+    0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f,
+    0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
+    0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+    0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
+    0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+    0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+    0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+    0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+    0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+    0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
+    0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_5 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0x00, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0x00, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0x00, 0xfe, 0xff,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_6 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x060c, 0x00ad, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f,
+    0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+    0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
+    0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
+    0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
+    0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f,
+    0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_6 [48 + 4 * 64] = {
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0xbf,
+    0x00, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_7 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x2018, 0x2019, 0x00a3, 0x0000, 0x0000, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x0000, 0x00ab, 0x00ac, 0x00ad, 0x0000, 0x2015,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7,
+    0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
+    0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+    0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+    0x03a0, 0x03a1, 0x0000, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
+    0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
+    0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
+    0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
+    0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
+    0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0x0000,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_7 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0xa3, 0x00, 0x00, 0xa6, 0xa7,
+    0xa8, 0xa9, 0x00, 0xab, 0xac, 0xad, 0x00, 0x00,
+    0xb0, 0xb1, 0xb2, 0xb3, 0x00, 0x00, 0x00, 0xb7,
+    0x00, 0x00, 0x00, 0xbb, 0x00, 0xbd, 0x00, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xaf, 0x00, 0x00,
+    0xa1, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xb4, 0xb5, 0xb6, 0x00,
+    0xb8, 0xb9, 0xba, 0x00, 0xbc, 0x00, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0x00, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_8 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0000, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017,
+    0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
+    0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
+    0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
+    0x05e8, 0x05e9, 0x05ea, 0x0000, 0x0000, 0x200e, 0x200f, 0x0000,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_8 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0x00, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfd, 0xfe,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdf,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_9 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_9 [48 + 5 * 64] = {
+    0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0x00, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0x00, 0x00, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0x00, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0x00, 0x00, 0xff,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd0, 0xf0,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xdd, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 0xfe,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_10 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7,
+    0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a,
+    0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7,
+    0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b,
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168,
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169,
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_10 [48 + 7 * 64] = {
+    0x00, 0x00, 0x01, 0x06, 0x02, 0x03, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xad, 0x00, 0x00,
+    0xb0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0xe0, 0x00, 0x00, 0xa1, 0xb1, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xc8, 0xe8, 0x00, 0x00,
+    0xa9, 0xb9, 0xa2, 0xb2, 0x00, 0x00, 0xcc, 0xec,
+    0xca, 0xea, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xa3, 0xb3, 0x00, 0x00, 0x00, 0x00,
+    0xa5, 0xb5, 0xa4, 0xb4, 0x00, 0x00, 0xc7, 0xe7,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa6, 0xb6,
+    0xff, 0x00, 0x00, 0xa8, 0xb8, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xd1, 0xf1, 0x00,
+    0x00, 0x00, 0xaf, 0xbf, 0xd2, 0xf2, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xaa, 0xba, 0x00, 0x00, 0x00, 0x00, 0xab, 0xbb,
+    0xd7, 0xf7, 0xae, 0xbe, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xd9, 0xf9, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xac, 0xbc, 0x00,
+    0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xbd, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0x00,
+    0x00, 0xc9, 0x00, 0xcb, 0x00, 0xcd, 0xce, 0xcf,
+    0xd0, 0x00, 0x00, 0xd3, 0xd4, 0xd5, 0xd6, 0x00,
+    0xd8, 0x00, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0x00, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0x00,
+    0x00, 0xe9, 0x00, 0xeb, 0x00, 0xed, 0xee, 0xef,
+    0xf0, 0x00, 0x00, 0xf3, 0xf4, 0xf5, 0xf6, 0x00,
+    0xf8, 0x00, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_11 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07,
+    0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
+    0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17,
+    0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
+    0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27,
+    0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
+    0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37,
+    0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0e3f,
+    0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47,
+    0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
+    0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57,
+    0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0x0000, 0x0000, 0x0000, 0x0000,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_11 [48 + 5 * 64] = {
+    0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
+    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,
+    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0x00, 0x00, 0x00, 0x00, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_13 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7,
+    0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7,
+    0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
+    0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112,
+    0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
+    0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7,
+    0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
+    0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113,
+    0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
+    0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7,
+    0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_13 [48 + 7 * 64] = {
+    0x00, 0x00, 0x01, 0x04, 0x06, 0x05, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0xa2, 0xa3, 0xa4, 0x00, 0xa6, 0xa7,
+    0x00, 0xa9, 0x00, 0xab, 0xac, 0xad, 0xae, 0x00,
+    0xb0, 0xb1, 0xb2, 0xb3, 0x00, 0xb5, 0xb6, 0xb7,
+    0x00, 0xb9, 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0x00,
+    0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xff, 0x00, 0x00, 0xb4, 0xa1, 0xa5, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xc4, 0xc5, 0xaf, 0x00,
+    0x00, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xd3, 0x00, 0xd5, 0xd6, 0xd7,
+    0xa8, 0x00, 0x00, 0x00, 0xdc, 0x00, 0x00, 0xdf,
+    0x00, 0x00, 0x00, 0x00, 0xe4, 0xe5, 0xbf, 0x00,
+    0x00, 0xe9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0xf3, 0x00, 0xf5, 0xf6, 0xf7,
+    0xb8, 0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00,
+    0x00, 0xd9, 0xf9, 0xd1, 0xf1, 0xd2, 0xf2, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xd4, 0xf4, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xba,
+    0x00, 0x00, 0xda, 0xfa, 0x00, 0x00, 0x00, 0x00,
+    0xd0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xdb, 0xfb, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xd8, 0xf8, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xca, 0xea, 0xdd, 0xfd, 0xde, 0xfe, 0x00,
+    0xc2, 0xe2, 0x00, 0x00, 0xc0, 0xe0, 0xc3, 0xe3,
+    0x00, 0x00, 0x00, 0x00, 0xc8, 0xe8, 0x00, 0x00,
+    0x00, 0x00, 0xc7, 0xe7, 0x00, 0x00, 0xcb, 0xeb,
+    0xc6, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xcc, 0xec, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xce, 0xee, 0x00, 0x00, 0xc1, 0xe1,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xcd, 0xed,
+    0x00, 0x00, 0x00, 0xcf, 0xef, 0x00, 0x00, 0x00,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_14 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7,
+    0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178,
+    0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56,
+    0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_14 [48 + 10 * 64] = {
+    0x00, 0x00, 0x01, 0x09, 0x04, 0x07, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0xa3, 0x00, 0x00, 0x00, 0xa7,
+    0x00, 0xa9, 0x00, 0x00, 0x00, 0xad, 0xae, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb6, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x03, 0x08, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xa1, 0xa2, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xa6, 0xab, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xb1,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xa4, 0xa5, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xb2, 0xb3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa8, 0xb8, 0xaa, 0xba, 0xbd, 0xbe, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xac, 0xbc, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xd0, 0xf0, 0xde, 0xfe,
+    0xaf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xb4, 0xb5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb7, 0xb9,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xbb, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xd7, 0xf7, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0x00, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0x00,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0x00, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0x00, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0x00,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x00, 0xff,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_15 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7,
+    0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7,
+    0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_15 [48 + 6 * 64] = {
+    0x00, 0x00, 0x01, 0x05, 0x00, 0x04, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0xa1, 0xa2, 0xa3, 0x00, 0xa5, 0x00, 0xa7,
+    0x00, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
+    0xb0, 0xb1, 0xb2, 0xb3, 0x00, 0xb5, 0xb6, 0xb7,
+    0x00, 0xb9, 0xba, 0xbb, 0x00, 0x00, 0x00, 0xbf,
+    0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xbc, 0xbd, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xa6, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xbe, 0x00, 0x00, 0x00, 0x00, 0xb4, 0xb8, 0x00,
+    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,
+    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
+    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
+    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
+};
+
+static const unsigned short xmlunicodetable_ISO8859_16 [128] = {
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7,
+    0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b,
+    0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7,
+    0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c,
+    0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a,
+    0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b,
+    0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff,
+};
+
+static const unsigned char xmltranscodetable_ISO8859_16 [48 + 9 * 64] = {
+    0x00, 0x00, 0x01, 0x08, 0x02, 0x03, 0x00, 0x00,
+    0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,
+    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
+    0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa7,
+    0x00, 0xa9, 0x00, 0xab, 0x00, 0xad, 0x00, 0x00,
+    0xb0, 0xb1, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xb7,
+    0x00, 0x00, 0x00, 0xbb, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xc3, 0xe3, 0xa1, 0xa2, 0xc5, 0xe5,
+    0x00, 0x00, 0x00, 0x00, 0xb2, 0xb9, 0x00, 0x00,
+    0xd0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xdd, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0xa3, 0xb3, 0xd1, 0xf1, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xd5, 0xf5, 0xbc, 0xbd, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0xd7, 0xf7, 0x00, 0x00, 0x00, 0x00,
+    0xa6, 0xa8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xd8, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xbe, 0xac, 0xae, 0xaf, 0xbf, 0xb4, 0xb8, 0x00,
+    0x06, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0xa4, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0xb5, 0xa5, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xaa, 0xba, 0xde, 0xfe, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xc0, 0xc1, 0xc2, 0x00, 0xc4, 0x00, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
+    0x00, 0x00, 0xd2, 0xd3, 0xd4, 0x00, 0xd6, 0x00,
+    0x00, 0xd9, 0xda, 0xdb, 0xdc, 0x00, 0x00, 0xdf,
+    0xe0, 0xe1, 0xe2, 0x00, 0xe4, 0x00, 0xe6, 0xe7,
+    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
+    0x00, 0x00, 0xf2, 0xf3, 0xf4, 0x00, 0xf6, 0x00,
+    0x00, 0xf9, 0xfa, 0xfb, 0xfc, 0x00, 0x00, 0xff,
+};
+
+#endif /* LIBXML_ISO8859X_ENABLED */

codegen/escape.inc

@@ -0,0 +1,66 @@
+static const char xmlEscapeContent[] = {
+      8, '&', '#', 'x', 'F', 'F', 'F', 'D', ';',   4, '&', '#',
+    '9', ';',   5, '&', '#', '1', '0', ';',   5, '&', '#', '1',
+    '3', ';',   6, '&', 'q', 'u', 'o', 't', ';',   5, '&', 'a',
+    'm', 'p', ';',   4, '&', 'l', 't', ';',   4, '&', 'g', 't',
+    ';',
+};
+
+static const signed char xmlEscapeTab[128] = {
+     0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1,  0,  0, 20,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    -1, -1, -1, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 44, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+static const signed char xmlEscapeTabQuot[128] = {
+     0,  0,  0,  0,  0,  0,  0,  0,  0, -1, -1,  0,  0, 20,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    -1, -1, 26, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 44, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+static const signed char xmlEscapeTabAttr[128] = {
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  9, 14,  0,  0, 20,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+    -1, -1, 26, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 44, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+#ifdef LIBXML_HTML_ENABLED
+
+static const signed char htmlEscapeTab[128] = {
+     0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 44, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+static const signed char htmlEscapeTabAttr[128] = {
+     0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, 26, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 44, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+};
+
+#endif /* LIBXML_HTML_ENABLED */

codegen/genCharset.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+
+def printHexTable(out, width, data):
+    s = ''
+
+    for i in range(len(data)):
+        if i % 8 == 0:
+            s += '    '
+        else:
+            s += ' '
+
+        s += f'0x{data[i]:{f"0{width}x"}},'
+
+        if i % 8 == 7:
+            out.write(s + '\n')
+            s = ''
+
+def genTranscodeTable(out, name, chars):
+    # For two-byte sequences, we look up a row with 64 entries.
+    row_ids = [ 0 ] * 32
+    # For three-byte sequences, we look up a plane with 64 entries,
+    # indexing into rows.
+    plane_ids = [ 0 ] * 16
+    data = [ 0 ] * 64
+
+    o = 0x80
+    for cp in chars:
+        if cp != 0:
+            if cp < 0x0800:
+                # The lower five bits of the first byte in a
+                # two-byte sequence are used to find the row.
+                i = cp // 64
+                index = row_ids[i]
+                if index == 0:
+                    index = len(data) // 64
+                    data += [ 0 ] * 64
+                    row_ids[i] = index
+            else:
+                # The lower four bits of the first byte in a
+                # three-byte sequence are used to find the plane.
+                i = cp // (64 * 64)
+                index2 = plane_ids[i]
+                if index2 == 0:
+                    index2 = len(data) // 64
+                    data += [ 0 ] * 64
+                    plane_ids[i] = index2
+
+                # The lower six bits of the second byte in a
+                # three-byte sequence are used to find the row.
+                i = index2 * 64 + cp // 64 % 64
+                index = data[i]
+                if index == 0:
+                    index = len(data) // 64
+                    data += [ 0 ] * 64
+                    data[i] = index
+
+            # The lower six bits in the last byte are
+            # used to lookup the codepoint.
+            data[index * 64 + cp % 64] = o
+
+        o += 1
+
+    out.write('static const unsigned short ')
+    out.write(f'xmlunicodetable_{name} [128] = {{\n')
+    printHexTable(out, 4, chars)
+    out.write('};\n\n')
+
+    num_chunks = len(data) // 64
+    out.write('static const unsigned char ')
+    out.write(f'xmltranscodetable_{name} [48 + {num_chunks} * 64] = {{\n')
+    printHexTable(out, 2, row_ids)
+    printHexTable(out, 2, plane_ids)
+    printHexTable(out, 2, data)
+    out.write('};\n\n')
+
+out = open(f'codegen/charset.inc', 'w')
+
+out.write('''/*
+ * Lookup tables for transcoding of 8-bit character sets.
+ *
+ * Generated with tools/genTranscode.py.
+ */
+
+''')
+
+genTranscodeTable(out, 'windows_1252', [
+    0x20ac, 0x0081, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021,
+    0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008d, 0x017d, 0x008f,
+    0x0090, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014,
+    0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x009d, 0x017e, 0x0178,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+])
+
+out.write(r'''#if !defined(LIBXML_ICONV_ENABLED) && \
+    !defined(LIBXML_ICU_ENABLED) && \
+    defined(LIBXML_ISO8859X_ENABLED)
+
+''')
+
+genTranscodeTable(out, 'ISO8859_2', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7,
+    0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
+    0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7,
+    0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
+    0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+    0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7,
+    0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+    0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+    0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7,
+    0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+])
+
+genTranscodeTable(out, 'ISO8859_3', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0126, 0x02d8, 0x00a3, 0x00a4, 0x0000, 0x0124, 0x00a7,
+    0x00a8, 0x0130, 0x015e, 0x011e, 0x0134, 0x00ad, 0x0000, 0x017b,
+    0x00b0, 0x0127, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x0125, 0x00b7,
+    0x00b8, 0x0131, 0x015f, 0x011f, 0x0135, 0x00bd, 0x0000, 0x017c,
+    0x00c0, 0x00c1, 0x00c2, 0x0000, 0x00c4, 0x010a, 0x0108, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0000, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x0120, 0x00d6, 0x00d7,
+    0x011c, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x016c, 0x015c, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x0000, 0x00e4, 0x010b, 0x0109, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0000, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x0121, 0x00f6, 0x00f7,
+    0x011d, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x016d, 0x015d, 0x02d9,
+])
+
+genTranscodeTable(out, 'ISO8859_4', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0138, 0x0156, 0x00a4, 0x0128, 0x013b, 0x00a7,
+    0x00a8, 0x0160, 0x0112, 0x0122, 0x0166, 0x00ad, 0x017d, 0x00af,
+    0x00b0, 0x0105, 0x02db, 0x0157, 0x00b4, 0x0129, 0x013c, 0x02c7,
+    0x00b8, 0x0161, 0x0113, 0x0123, 0x0167, 0x014a, 0x017e, 0x014b,
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x012a,
+    0x0110, 0x0145, 0x014c, 0x0136, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x0168, 0x016a, 0x00df,
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x012b,
+    0x0111, 0x0146, 0x014d, 0x0137, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x0169, 0x016b, 0x02d9,
+])
+
+genTranscodeTable(out, 'ISO8859_5', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0401, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
+    0x0408, 0x0409, 0x040a, 0x040b, 0x040c, 0x00ad, 0x040e, 0x040f,
+    0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417,
+    0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+    0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427,
+    0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+    0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437,
+    0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+    0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+    0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+    0x2116, 0x0451, 0x0452, 0x0453, 0x0454, 0x0455, 0x0456, 0x0457,
+    0x0458, 0x0459, 0x045a, 0x045b, 0x045c, 0x00a7, 0x045e, 0x045f,
+])
+
+genTranscodeTable(out, 'ISO8859_6', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x060c, 0x00ad, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x061b, 0x0000, 0x0000, 0x0000, 0x061f,
+    0x0000, 0x0621, 0x0622, 0x0623, 0x0624, 0x0625, 0x0626, 0x0627,
+    0x0628, 0x0629, 0x062a, 0x062b, 0x062c, 0x062d, 0x062e, 0x062f,
+    0x0630, 0x0631, 0x0632, 0x0633, 0x0634, 0x0635, 0x0636, 0x0637,
+    0x0638, 0x0639, 0x063a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0640, 0x0641, 0x0642, 0x0643, 0x0644, 0x0645, 0x0646, 0x0647,
+    0x0648, 0x0649, 0x064a, 0x064b, 0x064c, 0x064d, 0x064e, 0x064f,
+    0x0650, 0x0651, 0x0652, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+])
+
+genTranscodeTable(out, 'ISO8859_7', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x2018, 0x2019, 0x00a3, 0x0000, 0x0000, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x0000, 0x00ab, 0x00ac, 0x00ad, 0x0000, 0x2015,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x0384, 0x0385, 0x0386, 0x00b7,
+    0x0388, 0x0389, 0x038a, 0x00bb, 0x038c, 0x00bd, 0x038e, 0x038f,
+    0x0390, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
+    0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+    0x03a0, 0x03a1, 0x0000, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7,
+    0x03a8, 0x03a9, 0x03aa, 0x03ab, 0x03ac, 0x03ad, 0x03ae, 0x03af,
+    0x03b0, 0x03b1, 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7,
+    0x03b8, 0x03b9, 0x03ba, 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf,
+    0x03c0, 0x03c1, 0x03c2, 0x03c3, 0x03c4, 0x03c5, 0x03c6, 0x03c7,
+    0x03c8, 0x03c9, 0x03ca, 0x03cb, 0x03cc, 0x03cd, 0x03ce, 0x0000,
+])
+
+genTranscodeTable(out, 'ISO8859_8', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0000, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00d7, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00f7, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
+    0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x2017,
+    0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, 0x05d6, 0x05d7,
+    0x05d8, 0x05d9, 0x05da, 0x05db, 0x05dc, 0x05dd, 0x05de, 0x05df,
+    0x05e0, 0x05e1, 0x05e2, 0x05e3, 0x05e4, 0x05e5, 0x05e6, 0x05e7,
+    0x05e8, 0x05e9, 0x05ea, 0x0000, 0x0000, 0x200e, 0x200f, 0x0000,
+])
+
+genTranscodeTable(out, 'ISO8859_9', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7,
+    0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7,
+    0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x011e, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0130, 0x015e, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x011f, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0131, 0x015f, 0x00ff,
+])
+
+genTranscodeTable(out, 'ISO8859_10', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0112, 0x0122, 0x012a, 0x0128, 0x0136, 0x00a7,
+    0x013b, 0x0110, 0x0160, 0x0166, 0x017d, 0x00ad, 0x016a, 0x014a,
+    0x00b0, 0x0105, 0x0113, 0x0123, 0x012b, 0x0129, 0x0137, 0x00b7,
+    0x013c, 0x0111, 0x0161, 0x0167, 0x017e, 0x2015, 0x016b, 0x014b,
+    0x0100, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x012e,
+    0x010c, 0x00c9, 0x0118, 0x00cb, 0x0116, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x0145, 0x014c, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x0168,
+    0x00d8, 0x0172, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x0101, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x012f,
+    0x010d, 0x00e9, 0x0119, 0x00eb, 0x0117, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x0146, 0x014d, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x0169,
+    0x00f8, 0x0173, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x0138,
+])
+
+genTranscodeTable(out, 'ISO8859_11', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0e01, 0x0e02, 0x0e03, 0x0e04, 0x0e05, 0x0e06, 0x0e07,
+    0x0e08, 0x0e09, 0x0e0a, 0x0e0b, 0x0e0c, 0x0e0d, 0x0e0e, 0x0e0f,
+    0x0e10, 0x0e11, 0x0e12, 0x0e13, 0x0e14, 0x0e15, 0x0e16, 0x0e17,
+    0x0e18, 0x0e19, 0x0e1a, 0x0e1b, 0x0e1c, 0x0e1d, 0x0e1e, 0x0e1f,
+    0x0e20, 0x0e21, 0x0e22, 0x0e23, 0x0e24, 0x0e25, 0x0e26, 0x0e27,
+    0x0e28, 0x0e29, 0x0e2a, 0x0e2b, 0x0e2c, 0x0e2d, 0x0e2e, 0x0e2f,
+    0x0e30, 0x0e31, 0x0e32, 0x0e33, 0x0e34, 0x0e35, 0x0e36, 0x0e37,
+    0x0e38, 0x0e39, 0x0e3a, 0x0000, 0x0000, 0x0000, 0x0000, 0x0e3f,
+    0x0e40, 0x0e41, 0x0e42, 0x0e43, 0x0e44, 0x0e45, 0x0e46, 0x0e47,
+    0x0e48, 0x0e49, 0x0e4a, 0x0e4b, 0x0e4c, 0x0e4d, 0x0e4e, 0x0e4f,
+    0x0e50, 0x0e51, 0x0e52, 0x0e53, 0x0e54, 0x0e55, 0x0e56, 0x0e57,
+    0x0e58, 0x0e59, 0x0e5a, 0x0e5b, 0x0000, 0x0000, 0x0000, 0x0000,
+])
+
+genTranscodeTable(out, 'ISO8859_13', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x201d, 0x00a2, 0x00a3, 0x00a4, 0x201e, 0x00a6, 0x00a7,
+    0x00d8, 0x00a9, 0x0156, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00c6,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x201c, 0x00b5, 0x00b6, 0x00b7,
+    0x00f8, 0x00b9, 0x0157, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00e6,
+    0x0104, 0x012e, 0x0100, 0x0106, 0x00c4, 0x00c5, 0x0118, 0x0112,
+    0x010c, 0x00c9, 0x0179, 0x0116, 0x0122, 0x0136, 0x012a, 0x013b,
+    0x0160, 0x0143, 0x0145, 0x00d3, 0x014c, 0x00d5, 0x00d6, 0x00d7,
+    0x0172, 0x0141, 0x015a, 0x016a, 0x00dc, 0x017b, 0x017d, 0x00df,
+    0x0105, 0x012f, 0x0101, 0x0107, 0x00e4, 0x00e5, 0x0119, 0x0113,
+    0x010d, 0x00e9, 0x017a, 0x0117, 0x0123, 0x0137, 0x012b, 0x013c,
+    0x0161, 0x0144, 0x0146, 0x00f3, 0x014d, 0x00f5, 0x00f6, 0x00f7,
+    0x0173, 0x0142, 0x015b, 0x016b, 0x00fc, 0x017c, 0x017e, 0x2019,
+])
+
+genTranscodeTable(out, 'ISO8859_14', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x1e02, 0x1e03, 0x00a3, 0x010a, 0x010b, 0x1e0a, 0x00a7,
+    0x1e80, 0x00a9, 0x1e82, 0x1e0b, 0x1ef2, 0x00ad, 0x00ae, 0x0178,
+    0x1e1e, 0x1e1f, 0x0120, 0x0121, 0x1e40, 0x1e41, 0x00b6, 0x1e56,
+    0x1e81, 0x1e57, 0x1e83, 0x1e60, 0x1ef3, 0x1e84, 0x1e85, 0x1e61,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0174, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x1e6a,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x0176, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0175, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x1e6b,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x0177, 0x00ff,
+])
+
+genTranscodeTable(out, 'ISO8859_15', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7,
+    0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af,
+    0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7,
+    0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf,
+    0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7,
+    0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7,
+    0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff,
+])
+
+genTranscodeTable(out, 'ISO8859_16', [
+    0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087,
+    0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f,
+    0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097,
+    0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f,
+    0x00a0, 0x0104, 0x0105, 0x0141, 0x20ac, 0x201e, 0x0160, 0x00a7,
+    0x0161, 0x00a9, 0x0218, 0x00ab, 0x0179, 0x00ad, 0x017a, 0x017b,
+    0x00b0, 0x00b1, 0x010c, 0x0142, 0x017d, 0x201d, 0x00b6, 0x00b7,
+    0x017e, 0x010d, 0x0219, 0x00bb, 0x0152, 0x0153, 0x0178, 0x017c,
+    0x00c0, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0106, 0x00c6, 0x00c7,
+    0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf,
+    0x0110, 0x0143, 0x00d2, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x015a,
+    0x0170, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x0118, 0x021a, 0x00df,
+    0x00e0, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x0107, 0x00e6, 0x00e7,
+    0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef,
+    0x0111, 0x0144, 0x00f2, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x015b,
+    0x0171, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x0119, 0x021b, 0x00ff,
+])
+
+out.write('#endif /* LIBXML_ISO8859X_ENABLED */\n')
+
+out.close()

codegen/genEscape.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+
+entities = [
+    [ '',   '�' ],
+    [ '\t', '	' ],
+    [ '\n', '
' ],
+    [ '\r', '
' ],
+    [ '"',  '"' ],
+    [ '&',  '&' ],
+    [ '<',  '&lt;' ],
+    [ '>',  '&gt;' ],
+]
+
+offset = [ None ] * 128
+
+def gen_content(out):
+    pos = 0
+    r = ''
+
+    for rec in entities:
+        char, repl = rec
+
+        if char:
+            offset[ord(char)] = pos
+
+        if pos % 12 == 0: r += '\n    '
+        else: r += ' '
+        r += '%3d,' % len(repl)
+        pos += 1
+
+        for c in repl:
+            if pos % 12 == 0: r += '\n    '
+            else: r += ' '
+            r += "'%s'," % c
+            pos += 1
+
+    out.write('static const char xmlEscapeContent[] = {%s\n};\n\n' % r)
+
+def gen_tab(out, name, escape, is_xml):
+    r = ''
+
+    for i in range(0x80):
+
+        if chr(i) in escape:
+            v = offset[i]
+        elif i == 0:
+            v = 0
+        elif is_xml and i < 32 and i != 9 and i != 10:
+            v = 0
+        else:
+            v = -1
+
+        if i % 16 == 0: r += '\n    '
+        else: r += ' '
+        r += '%2d,' % v
+
+    out.write('static const signed char %s[128] = {%s\n};\n\n' % (name, r))
+
+with open('codegen/escape.inc', 'w') as out:
+    gen_content(out)
+
+    gen_tab(out, 'xmlEscapeTab', '\r&<>', True)
+    gen_tab(out, 'xmlEscapeTabQuot', '\r"&<>', True)
+    gen_tab(out, 'xmlEscapeTabAttr', '\t\n\r"&<>', True)
+
+    out.write('#ifdef LIBXML_HTML_ENABLED\n\n')
+    gen_tab(out, 'htmlEscapeTab', '&<>', False)
+    gen_tab(out, 'htmlEscapeTabAttr', '"&<>', False)
+    out.write('#endif /* LIBXML_HTML_ENABLED */\n')

codegen/genHtml5Ent.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+
+import json
+import sys
+from dataclasses import dataclass
+
+# The basic idea is to find named character references using binary
+# search. Since entity strings may not have a terminator, this doesn't
+# work if one entity string is a prefix of another. In this case,
+# we branch to a subtable after matching the prefix.
+#
+# We create separate initial tables based on the first character
+# of the entity name.
+#
+# The following tables are generated:
+#
+# htmlEntAlpha:   start and end of initial tables, indexing into
+#                 htmlEntValues
+# htmlEntValues:  concatenation of all table values, which index into
+#                 htmlEntStrings
+# htmlEntStrings: variable sized records containing entity name,
+#                 replacement and optionally the position of a
+#                 subtable
+
+try:
+    with open('entities.json') as json_data:
+        ents = json.load(json_data)
+except FileNotFoundError:
+    print('entities.json not found, try curl -LJO',
+          'https://html.spec.whatwg.org/entities.json')
+    sys.exit(1)
+
+def to_cchars(s):
+    r = []
+
+    for c in s.encode():
+        if c >= 0x20 and c <= 0x7E and c != ord("'") and c != ord('\\'):
+            v = f"'{chr(c)}'"
+        else:
+            v = c
+        r += [ v ]
+
+    return r
+
+@dataclass
+class PrefixStackEntry:
+    prefix: str
+    table_id: int
+
+@dataclass
+class AlphaFixup:
+    table_id: int
+    char: int
+
+@dataclass
+class StringFixup:
+    table_id: int
+    string_index: int
+    super_table_id: int
+    super_offset: int
+
+# Remove entity strings without trailing semicolon
+keys = (key for key in ents.keys() if key.endswith(';'))
+
+# Sort entity strings
+keys = sorted(keys, key=lambda k: k[1:-1])
+
+strings = []
+tables = []
+prefix_stack = []
+alpha_fixups = []
+string_fixups = []
+for i in range(64):
+    tables.append([])
+
+for i, key in enumerate(keys):
+    name = key[1:-1]
+
+    next_name = None
+    if i + 1 < len(keys):
+        next_name = keys[i+1][1:-1]
+
+    while prefix_stack and not name.startswith(prefix_stack[-1].prefix):
+        prefix_stack.pop()
+
+    # First character is initial prefix
+    if not prefix_stack:
+        table_id = len(tables)
+        tables.append([])
+
+        prefix_stack.append(PrefixStackEntry(name[0], table_id))
+        alpha_fixups.append(AlphaFixup(table_id, ord(name[0]) % 64))
+
+    string_index = len(strings)
+    table = tables[prefix_stack[-1].table_id]
+    table_index = len(table)
+    table.append(string_index)
+
+    name_offset = len(prefix_stack[-1].prefix)
+    name_chars = to_cchars(name[name_offset:])
+    repl_chars = to_cchars(ents[key]['characters'])
+    semicolon_flag = 0
+    if key[:-1] in ents:
+        semicolon_flag = 0x80
+
+    if next_name and next_name.startswith(name):
+        # Create subtable
+
+        strings += [
+            len(name_chars) | semicolon_flag | 0x40, *name_chars,
+            0, 0, # subtable position, to be fixed up
+            len(repl_chars), *repl_chars,
+        ]
+
+        table_id = len(tables)
+        tables.append([])
+
+        fixup_index = string_index + 1 + len(name_chars)
+        string_fixups.append(StringFixup(
+            table_id, fixup_index, prefix_stack[-1].table_id, table_index,
+        ))
+
+        prefix_stack.append(PrefixStackEntry(name, table_id))
+    else:
+        strings += [
+            len(name_chars) | semicolon_flag, *name_chars,
+            len(repl_chars), *repl_chars,
+        ]
+
+# Concat tables and record ranges
+ranges = [ 0 ]
+values = []
+for table in tables:
+    values += table
+    ranges.append(len(values))
+
+# Create alpha table
+alpha = [ 0 ] * (59 * 3)
+for fixup in alpha_fixups:
+    table_id, c = fixup.table_id, fixup.char
+    start = ranges[table_id]
+    end = ranges[table_id+1]
+    alpha[c*3:c*3+3] = [ start & 0xFF, start >> 8, end - start ]
+
+# Fix up subtable positions
+for fixup in string_fixups:
+    table_id, i = fixup.table_id, fixup.string_index
+    start = ranges[table_id]
+    end = ranges[table_id+1]
+    super_index = ranges[fixup.super_table_id] + fixup.super_offset
+    strings[i:i+2] = [ start - super_index, end - start ]
+
+# Print tables
+
+def gen_table(ctype, cname, values, fmt, elems_per_line):
+    count = len(values)
+    r = ''
+
+    for i in range(count):
+        if i != 0: r += ','
+        if i % elems_per_line == 0: r += '\n    '
+        else: r += ' '
+        r += fmt % values[i]
+
+    return f'static const {ctype} {cname}[{count}] = {{{r}\n}};\n\n'
+
+with open('codegen/html5ent.inc', 'w') as out:
+    out.write(gen_table('unsigned char', 'htmlEntAlpha', alpha, '%3d', 15))
+    out.write(gen_table('unsigned short', 'htmlEntValues', values, '%5d', 10))
+    out.write(gen_table('unsigned char', 'htmlEntStrings', strings, '%3s', 15))

codegen/genHtml5LibTests.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+
+import glob
+import json
+import re
+
+state_map = {
+    'Data state':          0,
+    'RCDATA state':        1,
+    'RAWTEXT state':       2,
+    'PLAINTEXT state':     3,
+    'Script data state':   4,
+    'CDATA section state': 5,
+}
+
+for filename in sorted(glob.glob('../html5lib-tests/tokenizer/*.test')):
+    match = re.search('/([^/]*).test$', filename)
+    if match is None:
+        continue
+    testname = match[1]
+    if testname == 'xmlViolation':
+        continue
+
+    with open(filename) as json_data:
+        root = json.load(json_data)
+
+    test_out = open(f'test/html-tokenizer/{testname}.test', 'w')
+    result_out = open(f'result/html-tokenizer/{testname}.test', 'w')
+
+    counter = 0
+
+    for tests in root.values():
+        for test in tests:
+            input = test['input']
+
+            # Skip surrogate tests
+            if re.search(r'\\uD[89A-F]', input, re.I):
+                continue
+
+            input = re.sub(r'\\u([A-Fa-f0-9]{4})',
+                           lambda m: chr(int(m[1], 16)),
+                           input)
+
+            output = ''
+            for token in test['output']:
+                if token[1] == '\0':
+                    continue
+
+                output += token[0] + '\n'
+
+                if token[0] == 'DOCTYPE':
+                    for i in range(1, 4):
+                        if token[i] is None:
+                            output += '<none>\n'
+                        else:
+                            output += token[i] + '\n'
+                else:
+                    output += token[1]
+                    if token[0] == 'StartTag':
+                        for name, value in token[2].items():
+                            output += f' {name}={value}'
+                    output += '\n'
+
+            output = re.sub(r'\\u([A-Fa-f0-9]{4})',
+                            lambda m: chr(int(m[1], 16)),
+                            output)
+
+            # The HTML5 spec splits handling of U+0000 across
+            # tokenizer and tree builder. We already ignore
+            # U+0000 in body text when tokenizing.
+            output = re.sub(r'\x00', '', output)
+
+            for state in test.get('initialStates', ['Data state']):
+                state_no = state_map.get(state)
+                if state_no is None:
+                    raise Exception(f'{filename}: unknown state: {state}')
+                if state_no == 5:
+                    continue
+
+                start_tag = test.get('lastStartTag', '-')
+
+                test_out.write(f'{counter} {start_tag} {state_no} '
+                               f'{len(input.encode())}\n')
+                test_out.write(input)
+                test_out.write('\n')
+
+                result_out.write(f'{counter}\n')
+                result_out.write(output)
+
+                counter += 1
+
+        test_out.close()
+        result_out.close()

codegen/genRanges.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+#
+# Portions of this script have been (shamelessly) stolen from the
+# prior work of Daniel Veillard (genUnicode.py)
+#
+# I, however, take full credit for any bugs, errors or difficulties :-)
+#
+# William Brack
+# October 2003
+#
+# 18 October 2003
+# Modified to maintain binary compatibility with previous library versions
+# by adding a suffix 'Q' ('quick') to the macro generated for the original,
+# function, and adding generation of a function (with the original name) which
+# instantiates the macro.
+#
+
+import sys
+import rangetab
+
+#
+# A routine to take a list of yes/no (1, 0) values and turn it
+# into a list of ranges.  This will later be used to determine whether
+# to generate single-byte lookup tables, or inline comparisons
+#
+def makeRange(lst):
+    ret = []
+    pos = 0
+    while pos < len(lst):
+        try:            # index generates exception if not present
+            s = lst[pos:].index(1)      # look for start of next range
+        except:
+            break                       # if no more, finished
+        pos += s                        # pointer to start of possible range
+        try:
+            e = lst[pos:].index(0)      # look for end of range
+            e += pos
+        except:                         # if no end, set to end of list
+            e = len(lst)
+        ret.append((pos, e-1))          # append range tuple to list
+        pos = e + 1                     # ready to check for next range
+    return ret
+
+# minTableSize gives the minimum number of ranges which must be present
+# before a 256-byte lookup table is produced.  If there are less than this
+# number, a macro with inline comparisons is generated
+minTableSize = 6
+
+# dictionary of functions, key=name, element contains char-map and range-list
+Functs = {}
+
+state = 0
+
+try:
+    defines = open("codegen/ranges.def", "r")
+except:
+    print("Missing codegen/ranges.def, aborting ...")
+    sys.exit(1)
+
+#
+# The lines in the .def file have three types:-
+#   name:   Defines a new function block
+#   ur:     Defines individual or ranges of unicode values
+#   end:    Indicates the end of the function block
+#
+# These lines are processed below.
+#
+for line in defines.readlines():
+    # ignore blank lines, or lines beginning with '#'
+    if line[0] == '#':
+        continue
+    line = line.strip()
+    if line == '':
+        continue
+    # split line into space-separated fields, then split on type
+    try:
+        fields = line.split(' ')
+        #
+        # name line:
+        #   validate any previous function block already ended
+        #   validate this function not already defined
+        #   initialize an entry in the function dicitonary
+        #       including a mask table with no values yet defined
+        #
+        if fields[0] == 'name':
+            name = fields[1]
+            if state != 0:
+                print("'name' %s found before previous name" \
+                      "completed" % (fields[1]))
+                continue
+            state = 1
+            if name in Functs:
+                print("name '%s' already present - may give" \
+                      " wrong results" % (name))
+            else:
+                # dict entry with two list elements (chdata, rangedata)
+                Functs[name] = [ [], [] ]
+                for v in range(256):
+                    Functs[name][0].append(0)
+        #
+        # end line:
+        #   validate there was a preceding function name line
+        #   set state to show no current function active
+        #
+        elif fields[0] == 'end':
+            if state == 0:
+                print("'end' found outside of function block")
+                continue
+            state = 0
+
+        #
+        # ur line:
+        #   validate function has been defined
+        #   process remaining fields on the line, which may be either
+        #       individual unicode values or ranges of values
+        #
+        elif fields[0] == 'ur':
+            if state != 1:
+                raise Exception("'ur' found outside of 'name' block")
+            for el in fields[1:]:
+                pos = el.find('..')
+                # pos <=0 means not a range, so must be individual value
+                if pos <= 0:
+                    # cheap handling of hex or decimal values
+                    if el[0:2] == '0x':
+                        value = int(el[2:],16)
+                    elif el[0] == "'":
+                        value = ord(el[1])
+                    else:
+                        value = int(el)
+                    if ((value < 0) | (value > 0x1fffff)):
+                        raise Exception('Illegal value (%s) in ch for'\
+                                ' name %s' % (el,name))
+                    # for ur we have only ranges (makes things simpler),
+                    # so convert val to range
+                    currange = (value, value)
+                # pos > 0 means this is a range, so isolate/validate
+                # the interval
+                else:
+                    # split the range into it's first-val, last-val
+                    (first, last) = el.split("..")
+                    # convert values from text into binary
+                    if first[0:2] == '0x':
+                        start = int(first[2:],16)
+                    elif first[0] == "'":
+                        start = ord(first[1])
+                    else:
+                        start = int(first)
+                    if last[0:2] == '0x':
+                        end = int(last[2:],16)
+                    elif last[0] == "'":
+                        end = ord(last[1])
+                    else:
+                        end = int(last)
+                    if (start < 0) | (end > 0x1fffff) | (start > end):
+                        raise Exception("Invalid range '%s'" % el)
+                    currange = (start, end)
+                # common path - 'currange' has the range, now take care of it
+                # We split on single-byte values vs. multibyte
+                if currange[1] < 0x100: # single-byte
+                    for ch in range(currange[0],currange[1]+1):
+                        # validate that value not previously defined
+                        if Functs[name][0][ch]:
+                            msg = "Duplicate ch value '%s' for name '%s'" % (el, name)
+                            raise Exception(msg)
+                        Functs[name][0][ch] = 1
+                else:                   # multi-byte
+                    if currange in Functs[name][1]:
+                        raise Exception("range already defined in" \
+                                " function")
+                    else:
+                        Functs[name][1].append(currange)
+
+    except:
+        print("Failed to process line: %s" % (line))
+        raise
+
+try:
+    output = open("codegen/ranges.inc", "w")
+except:
+    print("Failed to open codegen/ranges.inc")
+    sys.exit(1)
+
+#
+# Now output the generated data.
+#
+
+fkeys = sorted(Functs.keys())
+
+for f in fkeys:
+
+# First we convert the specified single-byte values into a group of ranges.
+    if max(Functs[f][0]) > 0:   # only check if at least one entry
+        rangeTable = makeRange(Functs[f][0])
+        numRanges = len(rangeTable)
+        if numRanges >= minTableSize:   # table is worthwhile
+            # write the constant data to the code file
+            output.write("const unsigned char %s_tab[256] = {\n" % f)
+            pline = "   "
+            for n in range(255):
+                pline += " 0x%02x," % Functs[f][0][n]
+                if len(pline) > 72:
+                    output.write(pline + "\n")
+                    pline = "   "
+            output.write(pline + " 0x%02x };\n\n" % Functs[f][0][255])
+
+#
+# Next we do the unicode ranges
+#
+
+for f in fkeys:
+    if len(Functs[f][1]) > 0:   # only generate if unicode ranges present
+        rangeTable = Functs[f][1]
+        rangeTable.sort()       # ascending tuple sequence
+        group = rangetab.gen_range_tables(output, f, '_srng', '_lrng',
+                                          rangeTable)
+
+        output.write("const xmlChRangeGroup %sGroup =\n\t%s;\n\n" %
+                     (f, group))
+
+output.close()
+

codegen/genTestApi.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+#
+# generate a test program for the API
+#
+
+import xml.etree.ElementTree as etree
+import os
+import re
+import sys
+
+import xmlmod
+
+# Globals
+
+dtors = {
+    'htmlDoc *': 'xmlFreeDoc',
+    'htmlParserCtxt *': 'htmlFreeParserCtxt',
+    'xmlAutomata *': 'xmlFreeAutomata',
+    'xmlBuffer *': 'xmlBufferFree',
+    'xmlCatalog *': 'xmlFreeCatalog',
+    'xmlChar *': 'xmlFree',
+    'xmlDOMWrapCtxt *': 'xmlDOMWrapFreeCtxt',
+    'xmlDict *': 'xmlDictFree',
+    'xmlDoc *': 'xmlFreeDoc',
+    'xmlDtd *': 'xmlFreeDtd',
+    'xmlEntitiesTable *': 'xmlFreeEntitiesTable',
+    'xmlElementContent *': 'xmlFreeElementContent',
+    'xmlEnumeration *': 'xmlFreeEnumeration',
+    'xmlList *': 'xmlListDelete',
+    'xmlModule *': 'xmlModuleFree',
+    'xmlMutex *': 'xmlFreeMutex',
+    'xmlNode *': 'xmlFreeNode',
+    'xmlNodeSet *': 'xmlXPathFreeNodeSet',
+    'xmlNs *': 'xmlFreeNs',
+    'xmlOutputBuffer *': 'xmlOutputBufferClose',
+    'xmlParserCtxt *': 'xmlFreeParserCtxt',
+    'xmlParserInputBuffer *': 'xmlFreeParserInputBuffer',
+    'xmlParserInput *': 'xmlFreeInputStream',
+    'xmlRMutex *': 'xmlFreeRMutex',
+    'xmlRelaxNGValidCtxt *': 'xmlRelaxNGFreeValidCtxt',
+    'xmlSaveCtxt *': 'xmlSaveClose',
+    'xmlSchemaFacet *': 'xmlSchemaFreeFacet',
+    'xmlSchemaVal *': 'xmlSchemaFreeValue',
+    'xmlSchemaValidCtxt *': 'xmlSchemaFreeValidCtxt',
+    'xmlTextWriter *': 'xmlFreeTextWriter',
+    'xmlURI *': 'xmlFreeURI',
+    'xmlValidCtxt *': 'xmlFreeValidCtxt',
+    'xmlXPathContext *': 'xmlXPathFreeContext',
+    'xmlXPathParserContext *': 'xmlXPathFreeParserContext',
+    'xmlXPathObject *': 'xmlXPathFreeObject',
+}
+
+blockList = {
+    # init/cleanup
+    'xmlCleanupParser': True,
+    'xmlInitParser': True,
+
+    # arg must be non-NULL
+    'xmlMemStrdupLoc': True,
+    'xmlMemoryStrdup': True,
+
+    # Returns void pointer which must be freed
+    'xmlMallocAtomicLoc': True,
+    'xmlMallocLoc': True,
+    'xmlMemMalloc': True,
+    'xmlMemRealloc': True,
+    'xmlReallocLoc': True,
+
+    # Would reset the error handler
+    'xmlSetStructuredErrorFunc': True,
+
+    # Prints errors
+    'xmlCatalogGetPublic': True,
+    'xmlCatalogGetSystem': True,
+    'xmlDebugDumpDTD': True,
+    'xmlDebugDumpDocument': True,
+    'xmlDebugDumpNode': True,
+    'xmlDebugDumpString': True,
+    'xmlParserError': True,
+    'xmlParserWarning': True,
+    'xmlParserValidityError': True,
+    'xmlParserValidityWarning': True,
+
+    # Internal parser unctions, ctxt must be non-NULL
+    'xmlParseAttribute': True,
+    'xmlParseAttributeListDecl': True,
+    'xmlParseAttributeType': True,
+    'xmlParseCDSect': True,
+    'xmlParseCharData': True,
+    'xmlParseCharRef': True,
+    'xmlParseComment': True,
+    'xmlParseDefaultDecl': True,
+    'xmlParseDocTypeDecl': True,
+    'xmlParseEndTag': True,
+    'xmlParseElement': True,
+    'xmlParseElementChildrenContentDecl': True,
+    'xmlParseElementContentDecl': True,
+    'xmlParseElementDecl': True,
+    'xmlParseElementMixedContentDecl': True,
+    'xmlParseEncName': True,
+    'xmlParseEncodingDecl': True,
+    'xmlParseEntityDecl': True,
+    'xmlParseEntityValue': True,
+    'xmlParseEnumeratedType': True,
+    'xmlParseEnumerationType': True,
+    'xmlParseExternalID': True,
+    'xmlParseExternalSubset': True,
+    'xmlParseMarkupDecl': True,
+    'xmlParseMisc': True,
+    'xmlParseName': True,
+    'xmlParseNmtoken': True,
+    'xmlParseNotationDecl': True,
+    'xmlParseNotationType': True,
+    'xmlParsePEReference': True,
+    'xmlParsePI': True,
+    'xmlParsePITarget': True,
+    'xmlParsePubidLiteral': True,
+    'xmlParseReference': True,
+    'xmlParseSDDecl': True,
+    'xmlParseStartTag': True,
+    'xmlParseSystemLiteral': True,
+    'xmlParseTextDecl': True,
+    'xmlParseVersionInfo': True,
+    'xmlParseVersionNum': True,
+    'xmlParseXMLDecl': True,
+    'xmlParserHandlePEReference': True,
+    'xmlSkipBlankChars': True,
+
+    # reads from stdin
+    'htmlReadFd': True,
+    'xmlReadFd': True,
+    'xmlReaderForFd': True,
+}
+
+# Parse document
+
+if len(sys.argv) > 1:
+    buildDir = sys.argv[1]
+else:
+    buildDir = '.'
+
+xmlDocDir = buildDir + '/doc/xml'
+
+filenames = {}
+functions = {}
+
+for file in os.listdir(xmlDocDir):
+    if not file.endswith('_8h.xml'):
+        continue
+
+    doc = etree.parse(xmlDocDir + '/' + file)
+
+    compound = doc.find('compounddef')
+    module = compound.find('compoundname').text
+    if not module.endswith('.h'):
+        continue
+    module = module[:-2]
+
+    for section in compound.findall('sectiondef'):
+        if section.get('kind') != 'func':
+            continue
+
+        for func in section.findall('memberdef'):
+            name = func.find('name').text
+            if name in blockList:
+                continue
+
+            module1, module2 = xmlmod.findModules(module, name)
+
+            cargs = []
+            skip = False
+            for arg in func.findall('param'):
+                atype = etree.tostring(arg.find('type'),
+                    method='text', encoding='unicode').rstrip()
+                if atype == 'void':
+                    continue
+                if atype == 'va_list':
+                    skip = True
+                    break
+                if re.search(r'(Ptr|\*)$', atype):
+                    cargs.append('NULL')
+                else:
+                    cargs.append('0')
+
+            if skip:
+                continue
+
+            mfunc = functions.get(module1)
+            if mfunc is None:
+                mfunc = {}
+                functions[module1] = mfunc
+
+            mmfunc = mfunc.get(module2)
+            if mmfunc is None:
+                mmfunc = {}
+                mfunc[module2] = mmfunc
+
+            code = f'{name}({', '.join(cargs)})'
+
+            rtype = etree.tostring(func.find('type'),
+                method='text', encoding='unicode').rstrip()
+            dtor = dtors.get(rtype)
+            if dtor is not None:
+                code = f'{dtor}({code})'
+            elif rtype == 'xmlHashTable *':
+                code = f'xmlHashFree({code}, NULL)'
+
+            mmfunc[name] = f'    {code};\n'
+
+# Write output
+
+test = open('testapi.c', 'w')
+
+test.write("""/*
+ * testapi.c: libxml2 API tester program.
+ *
+ * Automatically generated by gentest.py
+ *
+ * See Copyright for the status of this software.
+ */
+
+/* Disable deprecation warnings */
+#define XML_DEPRECATED
+
+#include "libxml.h"
+#include <libxml/HTMLparser.h>
+#include <libxml/HTMLtree.h>
+#include <libxml/c14n.h>
+#include <libxml/catalog.h>
+#include <libxml/debugXML.h>
+#include <libxml/parserInternals.h>
+#include <libxml/pattern.h>
+#include <libxml/relaxng.h>
+#include <libxml/schematron.h>
+#include <libxml/uri.h>
+#include <libxml/xinclude.h>
+#include <libxml/xlink.h>
+#include <libxml/xmlmodule.h>
+#include <libxml/xmlreader.h>
+#include <libxml/xmlsave.h>
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlschemastypes.h>
+#include <libxml/xmlwriter.h>
+#include <libxml/xpathInternals.h>
+#include <libxml/xpointer.h>
+
+static void
+ignoreError(void *userData ATTRIBUTE_UNUSED,
+            const xmlError *error ATTRIBUTE_UNUSED) {
+}
+
+int
+main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
+    xmlInitParser();
+    xmlSetStructuredErrorFunc(NULL, ignoreError);
+
+""")
+
+for module1 in sorted(functions.keys()):
+    mfunc = functions[module1]
+
+    if module1 != '':
+        test.write(f'#ifdef LIBXML_{module1}_ENABLED\n')
+
+    for module2 in sorted(mfunc.keys()):
+        mmfunc = mfunc[module2]
+
+        if module2 != '':
+            test.write(f'#ifdef LIBXML_{module2}_ENABLED\n')
+
+        for name in sorted(mmfunc.keys()):
+            test.write(mmfunc[name])
+
+        if module2 != '':
+            test.write(f'#endif /* LIBXML_{module2}_ENABLED */\n')
+
+    if module1 != '':
+        test.write(f'#endif /* LIBXML_{module1}_ENABLED */\n')
+
+    test.write('\n')
+
+test.write("""    xmlCleanupParser();
+    return 0;
+}
+""")

codegen/genUnicode.py

@@ -0,0 +1,252 @@
+#!/usr/bin/env python3
+#
+# Original script modified in November 2003 to take advantage of
+# the character-validation range routines, and updated to the
+# current Unicode information (Version 4.0.1)
+#
+# NOTE: there is an 'alias' facility for blocks which are not present in
+#	the current release, but are needed for ABI compatibility.  This
+#	must be accomplished MANUALLY!  Please see the comments below under
+#     'blockAliases'
+#
+import sys
+import string
+import rangetab
+
+#
+# blockAliases is a small hack - it is used for mapping block names which
+# were were used in the 3.1 release, but are missing or changed in the current
+# release.  The format is "OldBlockName:NewBlockName1[,NewBlockName2[,...]]"
+blockAliases = []
+blockAliases.append("CombiningMarksforSymbols:CombiningDiacriticalMarksforSymbols")
+blockAliases.append("Greek:GreekandCoptic")
+blockAliases.append("PrivateUse:PrivateUseArea,SupplementaryPrivateUseArea-A," + 
+	"SupplementaryPrivateUseArea-B")
+
+# minTableSize gives the minimum number of ranges which must be present
+# before a range table is produced.  If there are less than this
+# number, inline comparisons are generated
+minTableSize = 8
+
+blockfile = "Blocks-4.0.1.txt"
+catfile = "UnicodeData-4.0.1.txt"
+
+
+#
+# Now process the "blocks" file, reducing it to a dictionary
+# indexed by blockname, containing a tuple with the applicable
+# block range
+#
+BlockNames = {}
+try:
+    blocks = open(blockfile, "r")
+except:
+    print("Missing %s, aborting ..." % blockfile)
+    sys.exit(1)
+
+for line in blocks.readlines():
+    if line[0] == '#':
+        continue
+    line = line.strip()
+    if line == '':
+        continue
+    try:
+        fields = line.split(';')
+        range = fields[0].strip()
+        (start, end) = range.split("..")
+        name = fields[1].strip()
+        name = name.replace(' ', '')
+    except:
+        print("Failed to process line: %s" % (line))
+        continue
+    start = int(start, 16)
+    end = int(end, 16)
+    try:
+        BlockNames[name].append((start, end))
+    except:
+        BlockNames[name] = [(start, end)]
+blocks.close()
+print("Parsed %d blocks descriptions" % (len(BlockNames.keys())))
+
+for block in blockAliases:
+    alias = block.split(':')
+    alist = alias[1].split(',')
+    for comp in alist:
+        if comp in BlockNames:
+            if alias[0] not in BlockNames:
+                BlockNames[alias[0]] = []
+            for r in BlockNames[comp]:
+                BlockNames[alias[0]].append(r)
+        else:
+            print("Alias %s: %s not in Blocks" % (alias[0], comp))
+            continue
+
+#
+# Next process the Categories file. This is more complex, since
+# the file is in code sequence, and we need to invert it.  We use
+# a dictionary with index category-name, with each entry containing
+# all the ranges (codepoints) of that category.  Note that category
+# names comprise two parts - the general category, and the "subclass"
+# within that category.  Therefore, both "general category" (which is
+# the first character of the 2-character category-name) and the full
+# (2-character) name are entered into this dictionary.
+#
+try:
+    data = open(catfile, "r")
+except:
+    print("Missing %s, aborting ..." % catfile)
+    sys.exit(1)
+
+nbchar = 0;
+Categories = {}
+for line in data.readlines():
+    if line[0] == '#':
+        continue
+    line = line.strip()
+    if line == '':
+        continue
+    try:
+        fields = line.split(';')
+        point = fields[0].strip()
+        value = 0
+        while point != '':
+            value = value * 16
+            if point[0] >= '0' and point[0] <= '9':
+                value = value + ord(point[0]) - ord('0')
+            elif point[0] >= 'A' and point[0] <= 'F':
+                value = value + 10 + ord(point[0]) - ord('A')
+            elif point[0] >= 'a' and point[0] <= 'f':
+                value = value + 10 + ord(point[0]) - ord('a')
+            point = point[1:]
+        name = fields[2]
+    except:
+        print("Failed to process line: %s" % (line))
+        continue
+    
+    nbchar = nbchar + 1
+    # update entry for "full name"
+    try:
+        Categories[name].append(value)
+    except:
+        try:
+            Categories[name] = [value]
+        except:
+            print("Failed to process line: %s" % (line))
+    # update "general category" name
+    try:
+        Categories[name[0]].append(value)
+    except:
+        try:
+            Categories[name[0]] = [value]
+        except:
+            print("Failed to process line: %s" % (line))
+
+data.close()
+print("Parsed %d char generating %d categories" % (nbchar, len(Categories.keys())))
+
+#
+# The data is now all read.  Time to process it into a more useful form.
+#
+# reduce the number list into ranges
+for cat in Categories.keys():
+    list = Categories[cat]
+    start = -1
+    prev = -1
+    end = -1
+    ranges = []
+    for val in list:
+        if start == -1:
+            start = val
+            prev = val
+            continue
+        elif val == prev + 1:
+            prev = val
+            continue
+        elif prev == start:
+            ranges.append((prev, prev))
+            start = val
+            prev = val
+            continue
+        else:
+            ranges.append((start, prev))
+            start = val
+            prev = val
+            continue
+    if prev == start:
+        ranges.append((prev, prev))
+    else:
+        ranges.append((start, prev))
+    Categories[cat] = ranges
+
+#
+# Assure all data is in alphabetic order, since we will be doing binary
+# searches on the tables.
+#
+bkeys = sorted(BlockNames.keys())
+
+ckeys = sorted(Categories.keys())
+
+#
+# Generate the resulting files
+#
+try:
+    output = open("codegen/unicode.inc", "w")
+except:
+    print("Failed to open codegen/unicode.inc")
+    sys.exit(1)
+
+#
+# For any categories with more than minTableSize ranges we generate
+# a range table suitable for xmlCharInRange
+#
+for name in ckeys:
+    if len(Categories[name]) <= minTableSize or name == 'Cs':
+        continue
+    ranges = Categories[name]
+    group = rangetab.gen_range_tables(output, 'xml' + name, 'S', 'L', ranges)
+    output.write("static const xmlChRangeGroup xml%sG = %s;\n\n" %
+                 (name, group))
+
+for name in ckeys:
+    if name == 'Cs':
+        continue
+    ranges = Categories[name]
+    output.write("static int\nxmlUCSIsCat%s(int code) {\n" % name)
+    if len(Categories[name]) > minTableSize:
+        output.write("    return(xmlCharInRange((unsigned int)code, &xml%sG)"
+            % name)
+    else:
+        start = 1
+        for range in ranges:
+            (begin, end) = range;
+            if start:
+                output.write("    return(");
+                start = 0
+            else:
+                output.write(" ||\n           ");
+            if (begin == end):
+                output.write("(code == %s)" % (hex(begin)))
+            else:
+                output.write("((code >= %s) && (code <= %s))" % (
+                         hex(begin), hex(end)))
+    output.write(");\n}\n\n")
+
+#
+# Range tables for blocks
+#
+
+blockGroups = ''
+for block in bkeys:
+    name = block.replace('-', '')
+    ranges = BlockNames[block]
+    group = rangetab.gen_range_tables(output, 'xml' + name, 'S', 'L', ranges)
+    output.write("\n")
+    if blockGroups != '':
+        blockGroups += ",\n"
+    blockGroups += '  {"%s",\n   %s}' % (block, group)
+
+output.write("static const xmlUnicodeRange xmlUnicodeBlocks[] = {\n")
+output.write(blockGroups)
+output.write("\n};\n\n")
+
+output.close()

codegen/ranges.def

@@ -0,0 +1,361 @@
+name xmlIsChar
+ur 0x9 
+ur 0xA 
+ur 0xD 
+ur 0x20..0xFF 
+ur 0x0100..0xD7FF 
+ur 0xE000..0xFFFD 
+ur 0x10000..0x10FFFF
+end xmlIsChar
+
+name xmlIsPubidChar
+ur 0x20 0x0d 0x0a 'a'..'z' 'A'..'Z' '0'..'9'
+ur '-' 0x27 '(' ')' '+' ',' '.' '/'
+ur ':' '=' '?' ';' '!' '*' '#' '@'
+ur '$' '_' '%'
+end
+
+name xmlIsBlank
+ur 0x09 0x0a 0x0d 0x20
+end xmlIsBlank
+
+name xmlIsBaseChar
+ur 0x0041..0x005A 
+ur 0x0061..0x007A 
+ur 0x00C0..0x00D6 
+ur 0x00D8..0x00F6 
+ur 0x00F8..0x00FF 
+ur 0x0100..0x0131 
+ur 0x0134..0x013E 
+ur 0x0141..0x0148 
+ur 0x014A..0x017E 
+ur 0x0180..0x01C3 
+ur 0x01CD..0x01F0 
+ur 0x01F4..0x01F5 
+ur 0x01FA..0x0217 
+ur 0x0250..0x02A8 
+ur 0x02BB..0x02C1 
+ur 0x0386 
+ur 0x0388..0x038A 
+ur 0x038C 
+ur 0x038E..0x03A1 
+ur 0x03A3..0x03CE 
+ur 0x03D0..0x03D6 
+ur 0x03DA 
+ur 0x03DC 
+ur 0x03DE 
+ur 0x03E0 
+ur 0x03E2..0x03F3 
+ur 0x0401..0x040C 
+ur 0x040E..0x044F 
+ur 0x0451..0x045C 
+ur 0x045E..0x0481 
+ur 0x0490..0x04C4 
+ur 0x04C7..0x04C8 
+ur 0x04CB..0x04CC 
+ur 0x04D0..0x04EB 
+ur 0x04EE..0x04F5 
+ur 0x04F8..0x04F9 
+ur 0x0531..0x0556 
+ur 0x0559 
+ur 0x0561..0x0586 
+ur 0x05D0..0x05EA 
+ur 0x05F0..0x05F2 
+ur 0x0621..0x063A 
+ur 0x0641..0x064A 
+ur 0x0671..0x06B7 
+ur 0x06BA..0x06BE 
+ur 0x06C0..0x06CE 
+ur 0x06D0..0x06D3 
+ur 0x06D5 
+ur 0x06E5..0x06E6 
+ur 0x0905..0x0939 
+ur 0x093D 
+ur 0x0958..0x0961 
+ur 0x0985..0x098C 
+ur 0x098F..0x0990 
+ur 0x0993..0x09A8 
+ur 0x09AA..0x09B0 
+ur 0x09B2 
+ur 0x09B6..0x09B9 
+ur 0x09DC..0x09DD 
+ur 0x09DF..0x09E1 
+ur 0x09F0..0x09F1 
+ur 0x0A05..0x0A0A 
+ur 0x0A0F..0x0A10 
+ur 0x0A13..0x0A28 
+ur 0x0A2A..0x0A30 
+ur 0x0A32..0x0A33 
+ur 0x0A35..0x0A36 
+ur 0x0A38..0x0A39 
+ur 0x0A59..0x0A5C 
+ur 0x0A5E 
+ur 0x0A72..0x0A74 
+ur 0x0A85..0x0A8B 
+ur 0x0A8D 
+ur 0x0A8F..0x0A91 
+ur 0x0A93..0x0AA8 
+ur 0x0AAA..0x0AB0 
+ur 0x0AB2..0x0AB3 
+ur 0x0AB5..0x0AB9 
+ur 0x0ABD 
+ur 0x0AE0 
+ur 0x0B05..0x0B0C 
+ur 0x0B0F..0x0B10 
+ur 0x0B13..0x0B28 
+ur 0x0B2A..0x0B30 
+ur 0x0B32..0x0B33 
+ur 0x0B36..0x0B39 
+ur 0x0B3D 
+ur 0x0B5C..0x0B5D 
+ur 0x0B5F..0x0B61 
+ur 0x0B85..0x0B8A 
+ur 0x0B8E..0x0B90 
+ur 0x0B92..0x0B95 
+ur 0x0B99..0x0B9A 
+ur 0x0B9C 
+ur 0x0B9E..0x0B9F 
+ur 0x0BA3..0x0BA4 
+ur 0x0BA8..0x0BAA 
+ur 0x0BAE..0x0BB5 
+ur 0x0BB7..0x0BB9 
+ur 0x0C05..0x0C0C 
+ur 0x0C0E..0x0C10 
+ur 0x0C12..0x0C28 
+ur 0x0C2A..0x0C33 
+ur 0x0C35..0x0C39 
+ur 0x0C60..0x0C61 
+ur 0x0C85..0x0C8C 
+ur 0x0C8E..0x0C90 
+ur 0x0C92..0x0CA8 
+ur 0x0CAA..0x0CB3 
+ur 0x0CB5..0x0CB9 
+ur 0x0CDE 
+ur 0x0CE0..0x0CE1 
+ur 0x0D05..0x0D0C 
+ur 0x0D0E..0x0D10 
+ur 0x0D12..0x0D28 
+ur 0x0D2A..0x0D39 
+ur 0x0D60..0x0D61 
+ur 0x0E01..0x0E2E 
+ur 0x0E30 
+ur 0x0E32..0x0E33 
+ur 0x0E40..0x0E45 
+ur 0x0E81..0x0E82 
+ur 0x0E84 
+ur 0x0E87..0x0E88 
+ur 0x0E8A 
+ur 0x0E8D 
+ur 0x0E94..0x0E97 
+ur 0x0E99..0x0E9F 
+ur 0x0EA1..0x0EA3 
+ur 0x0EA5 
+ur 0x0EA7 
+ur 0x0EAA..0x0EAB 
+ur 0x0EAD..0x0EAE 
+ur 0x0EB0 
+ur 0x0EB2..0x0EB3 
+ur 0x0EBD 
+ur 0x0EC0..0x0EC4 
+ur 0x0F40..0x0F47 
+ur 0x0F49..0x0F69 
+ur 0x10A0..0x10C5 
+ur 0x10D0..0x10F6 
+ur 0x1100 
+ur 0x1102..0x1103 
+ur 0x1105..0x1107 
+ur 0x1109 
+ur 0x110B..0x110C 
+ur 0x110E..0x1112 
+ur 0x113C 
+ur 0x113E 
+ur 0x1140 
+ur 0x114C 
+ur 0x114E 
+ur 0x1150 
+ur 0x1154..0x1155 
+ur 0x1159 
+ur 0x115F..0x1161 
+ur 0x1163 
+ur 0x1165 
+ur 0x1167 
+ur 0x1169 
+ur 0x116D..0x116E 
+ur 0x1172..0x1173 
+ur 0x1175 
+ur 0x119E 
+ur 0x11A8 
+ur 0x11AB 
+ur 0x11AE..0x11AF 
+ur 0x11B7..0x11B8 
+ur 0x11BA 
+ur 0x11BC..0x11C2 
+ur 0x11EB 
+ur 0x11F0 
+ur 0x11F9 
+ur 0x1E00..0x1E9B 
+ur 0x1EA0..0x1EF9 
+ur 0x1F00..0x1F15 
+ur 0x1F18..0x1F1D 
+ur 0x1F20..0x1F45 
+ur 0x1F48..0x1F4D 
+ur 0x1F50..0x1F57 
+ur 0x1F59 
+ur 0x1F5B 
+ur 0x1F5D 
+ur 0x1F5F..0x1F7D 
+ur 0x1F80..0x1FB4 
+ur 0x1FB6..0x1FBC 
+ur 0x1FBE 
+ur 0x1FC2..0x1FC4 
+ur 0x1FC6..0x1FCC 
+ur 0x1FD0..0x1FD3 
+ur 0x1FD6..0x1FDB 
+ur 0x1FE0..0x1FEC 
+ur 0x1FF2..0x1FF4 
+ur 0x1FF6..0x1FFC 
+ur 0x2126 
+ur 0x212A..0x212B 
+ur 0x212E 
+ur 0x2180..0x2182 
+ur 0x3041..0x3094 
+ur 0x30A1..0x30FA 
+ur 0x3105..0x312C 
+ur 0xAC00..0xD7A3
+end xmlIsBaseChar
+
+name xmlIsIdeographic
+ur 0x4E00..0x9FA5 
+ur 0x3007 
+ur 0x3021..0x3029
+end xmlIsIdeographic
+
+name xmlIsCombining
+ur 0x0300..0x0345 
+ur 0x0360..0x0361 
+ur 0x0483..0x0486 
+ur 0x0591..0x05A1 
+ur 0x05A3..0x05B9 
+ur 0x05BB..0x05BD 
+ur 0x05BF 
+ur 0x05C1..0x05C2 
+ur 0x05C4 
+ur 0x064B..0x0652 
+ur 0x0670 
+ur 0x06D6..0x06DC 
+ur 0x06DD..0x06DF 
+ur 0x06E0..0x06E4 
+ur 0x06E7..0x06E8 
+ur 0x06EA..0x06ED 
+ur 0x0901..0x0903 
+ur 0x093C 
+ur 0x093E..0x094C 
+ur 0x094D 
+ur 0x0951..0x0954 
+ur 0x0962..0x0963 
+ur 0x0981..0x0983 
+ur 0x09BC 
+ur 0x09BE 
+ur 0x09BF 
+ur 0x09C0..0x09C4 
+ur 0x09C7..0x09C8 
+ur 0x09CB..0x09CD 
+ur 0x09D7 
+ur 0x09E2..0x09E3 
+ur 0x0A02 
+ur 0x0A3C 
+ur 0x0A3E 
+ur 0x0A3F 
+ur 0x0A40..0x0A42 
+ur 0x0A47..0x0A48 
+ur 0x0A4B..0x0A4D 
+ur 0x0A70..0x0A71 
+ur 0x0A81..0x0A83 
+ur 0x0ABC 
+ur 0x0ABE..0x0AC5 
+ur 0x0AC7..0x0AC9 
+ur 0x0ACB..0x0ACD 
+ur 0x0B01..0x0B03 
+ur 0x0B3C 
+ur 0x0B3E..0x0B43 
+ur 0x0B47..0x0B48 
+ur 0x0B4B..0x0B4D 
+ur 0x0B56..0x0B57 
+ur 0x0B82..0x0B83 
+ur 0x0BBE..0x0BC2 
+ur 0x0BC6..0x0BC8 
+ur 0x0BCA..0x0BCD 
+ur 0x0BD7 
+ur 0x0C01..0x0C03 
+ur 0x0C3E..0x0C44 
+ur 0x0C46..0x0C48 
+ur 0x0C4A..0x0C4D 
+ur 0x0C55..0x0C56 
+ur 0x0C82..0x0C83 
+ur 0x0CBE..0x0CC4 
+ur 0x0CC6..0x0CC8 
+ur 0x0CCA..0x0CCD 
+ur 0x0CD5..0x0CD6 
+ur 0x0D02..0x0D03 
+ur 0x0D3E..0x0D43 
+ur 0x0D46..0x0D48 
+ur 0x0D4A..0x0D4D 
+ur 0x0D57 
+ur 0x0E31 
+ur 0x0E34..0x0E3A 
+ur 0x0E47..0x0E4E 
+ur 0x0EB1 
+ur 0x0EB4..0x0EB9 
+ur 0x0EBB..0x0EBC 
+ur 0x0EC8..0x0ECD 
+ur 0x0F18..0x0F19 
+ur 0x0F35 
+ur 0x0F37 
+ur 0x0F39 
+ur 0x0F3E 
+ur 0x0F3F 
+ur 0x0F71..0x0F84 
+ur 0x0F86..0x0F8B 
+ur 0x0F90..0x0F95 
+ur 0x0F97 
+ur 0x0F99..0x0FAD 
+ur 0x0FB1..0x0FB7 
+ur 0x0FB9 
+ur 0x20D0..0x20DC 
+ur 0x20E1 
+ur 0x302A..0x302F 
+ur 0x3099 
+ur 0x309A
+end xmlIsCombining
+
+name xmlIsDigit
+ur 0x0030..0x0039 
+ur 0x0660..0x0669 
+ur 0x06F0..0x06F9 
+ur 0x0966..0x096F 
+ur 0x09E6..0x09EF 
+ur 0x0A66..0x0A6F 
+ur 0x0AE6..0x0AEF 
+ur 0x0B66..0x0B6F 
+ur 0x0BE7..0x0BEF 
+ur 0x0C66..0x0C6F 
+ur 0x0CE6..0x0CEF 
+ur 0x0D66..0x0D6F 
+ur 0x0E50..0x0E59 
+ur 0x0ED0..0x0ED9 
+ur 0x0F20..0x0F29
+end xmlIsDigit
+
+name xmlIsExtender
+ur 0x00B7 
+ur 0x02D0 
+ur 0x02D1 
+ur 0x0387 
+ur 0x0640 
+ur 0x0E46 
+ur 0x0EC6 
+ur 0x3005 
+ur 0x3031..0x3035 
+ur 0x309D..0x309E 
+ur 0x30FC..0x30FE
+end xmlIsExtender

codegen/ranges.inc

@@ -0,0 +1,131 @@
+const unsigned char xmlIsPubidChar_tab[256] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01,
+    0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
+    0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00 };
+
+static const xmlChSRange xmlIsBaseChar_srng[] = {{0x100, 0x131},
+    {0x134, 0x13e}, {0x141, 0x148}, {0x14a, 0x17e}, {0x180, 0x1c3},
+    {0x1cd, 0x1f0}, {0x1f4, 0x1f5}, {0x1fa, 0x217}, {0x250, 0x2a8},
+    {0x2bb, 0x2c1}, {0x386, 0x386}, {0x388, 0x38a}, {0x38c, 0x38c},
+    {0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3d6}, {0x3da, 0x3da},
+    {0x3dc, 0x3dc}, {0x3de, 0x3de}, {0x3e0, 0x3e0}, {0x3e2, 0x3f3},
+    {0x401, 0x40c}, {0x40e, 0x44f}, {0x451, 0x45c}, {0x45e, 0x481},
+    {0x490, 0x4c4}, {0x4c7, 0x4c8}, {0x4cb, 0x4cc}, {0x4d0, 0x4eb},
+    {0x4ee, 0x4f5}, {0x4f8, 0x4f9}, {0x531, 0x556}, {0x559, 0x559},
+    {0x561, 0x586}, {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a},
+    {0x641, 0x64a}, {0x671, 0x6b7}, {0x6ba, 0x6be}, {0x6c0, 0x6ce},
+    {0x6d0, 0x6d3}, {0x6d5, 0x6d5}, {0x6e5, 0x6e6}, {0x905, 0x939},
+    {0x93d, 0x93d}, {0x958, 0x961}, {0x985, 0x98c}, {0x98f, 0x990},
+    {0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, {0x9b6, 0x9b9},
+    {0x9dc, 0x9dd}, {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a},
+    {0xa0f, 0xa10}, {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33},
+    {0xa35, 0xa36}, {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e},
+    {0xa72, 0xa74}, {0xa85, 0xa8b}, {0xa8d, 0xa8d}, {0xa8f, 0xa91},
+    {0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3}, {0xab5, 0xab9},
+    {0xabd, 0xabd}, {0xae0, 0xae0}, {0xb05, 0xb0c}, {0xb0f, 0xb10},
+    {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb36, 0xb39},
+    {0xb3d, 0xb3d}, {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb85, 0xb8a},
+    {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c},
+    {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5},
+    {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28},
+    {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c},
+    {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9},
+    {0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c}, {0xd0e, 0xd10},
+    {0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61}, {0xe01, 0xe2e},
+    {0xe30, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45}, {0xe81, 0xe82},
+    {0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a}, {0xe8d, 0xe8d},
+    {0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xea5, 0xea5},
+    {0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeae}, {0xeb0, 0xeb0},
+    {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, {0xf40, 0xf47},
+    {0xf49, 0xf69}, {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x1100},
+    {0x1102, 0x1103}, {0x1105, 0x1107}, {0x1109, 0x1109}, {0x110b, 0x110c},
+    {0x110e, 0x1112}, {0x113c, 0x113c}, {0x113e, 0x113e}, {0x1140, 0x1140},
+    {0x114c, 0x114c}, {0x114e, 0x114e}, {0x1150, 0x1150}, {0x1154, 0x1155},
+    {0x1159, 0x1159}, {0x115f, 0x1161}, {0x1163, 0x1163}, {0x1165, 0x1165},
+    {0x1167, 0x1167}, {0x1169, 0x1169}, {0x116d, 0x116e}, {0x1172, 0x1173},
+    {0x1175, 0x1175}, {0x119e, 0x119e}, {0x11a8, 0x11a8}, {0x11ab, 0x11ab},
+    {0x11ae, 0x11af}, {0x11b7, 0x11b8}, {0x11ba, 0x11ba}, {0x11bc, 0x11c2},
+    {0x11eb, 0x11eb}, {0x11f0, 0x11f0}, {0x11f9, 0x11f9}, {0x1e00, 0x1e9b},
+    {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45},
+    {0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b},
+    {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc},
+    {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3},
+    {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc},
+    {0x2126, 0x2126}, {0x212a, 0x212b}, {0x212e, 0x212e}, {0x2180, 0x2182},
+    {0x3041, 0x3094}, {0x30a1, 0x30fa}, {0x3105, 0x312c}, {0xac00, 0xd7a3}};
+const xmlChRangeGroup xmlIsBaseCharGroup =
+	{197,0,xmlIsBaseChar_srng,NULL};
+
+static const xmlChSRange xmlIsChar_srng[] = {{0x100, 0xd7ff},
+    {0xe000, 0xfffd}};
+static const xmlChLRange xmlIsChar_lrng[] = {{0x10000, 0x10ffff}};
+const xmlChRangeGroup xmlIsCharGroup =
+	{2,1,xmlIsChar_srng,xmlIsChar_lrng};
+
+static const xmlChSRange xmlIsCombining_srng[] = {{0x300, 0x345},
+    {0x360, 0x361}, {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9},
+    {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4},
+    {0x64b, 0x652}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6dd, 0x6df},
+    {0x6e0, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x901, 0x903},
+    {0x93c, 0x93c}, {0x93e, 0x94c}, {0x94d, 0x94d}, {0x951, 0x954},
+    {0x962, 0x963}, {0x981, 0x983}, {0x9bc, 0x9bc}, {0x9be, 0x9be},
+    {0x9bf, 0x9bf}, {0x9c0, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd},
+    {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa02, 0xa02}, {0xa3c, 0xa3c},
+    {0xa3e, 0xa3e}, {0xa3f, 0xa3f}, {0xa40, 0xa42}, {0xa47, 0xa48},
+    {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa83}, {0xabc, 0xabc},
+    {0xabe, 0xac5}, {0xac7, 0xac9}, {0xacb, 0xacd}, {0xb01, 0xb03},
+    {0xb3c, 0xb3c}, {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d},
+    {0xb56, 0xb57}, {0xb82, 0xb83}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8},
+    {0xbca, 0xbcd}, {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44},
+    {0xc46, 0xc48}, {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83},
+    {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6},
+    {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d},
+    {0xd57, 0xd57}, {0xe31, 0xe31}, {0xe34, 0xe3a}, {0xe47, 0xe4e},
+    {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc}, {0xec8, 0xecd},
+    {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37}, {0xf39, 0xf39},
+    {0xf3e, 0xf3e}, {0xf3f, 0xf3f}, {0xf71, 0xf84}, {0xf86, 0xf8b},
+    {0xf90, 0xf95}, {0xf97, 0xf97}, {0xf99, 0xfad}, {0xfb1, 0xfb7},
+    {0xfb9, 0xfb9}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, {0x302a, 0x302f},
+    {0x3099, 0x3099}, {0x309a, 0x309a}};
+const xmlChRangeGroup xmlIsCombiningGroup =
+	{95,0,xmlIsCombining_srng,NULL};
+
+static const xmlChSRange xmlIsDigit_srng[] = {{0x660, 0x669},
+    {0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f},
+    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f},
+    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
+    {0xf20, 0xf29}};
+const xmlChRangeGroup xmlIsDigitGroup =
+	{14,0,xmlIsDigit_srng,NULL};
+
+static const xmlChSRange xmlIsExtender_srng[] = {{0x2d0, 0x2d0},
+    {0x2d1, 0x2d1}, {0x387, 0x387}, {0x640, 0x640}, {0xe46, 0xe46},
+    {0xec6, 0xec6}, {0x3005, 0x3005}, {0x3031, 0x3035}, {0x309d, 0x309e},
+    {0x30fc, 0x30fe}};
+const xmlChRangeGroup xmlIsExtenderGroup =
+	{10,0,xmlIsExtender_srng,NULL};
+
+static const xmlChSRange xmlIsIdeographic_srng[] = {{0x3007, 0x3007},
+    {0x3021, 0x3029}, {0x4e00, 0x9fa5}};
+const xmlChRangeGroup xmlIsIdeographicGroup =
+	{3,0,xmlIsIdeographic_srng,NULL};
+

codegen/rangetab.py

@@ -0,0 +1,34 @@
+def gen_range_tables(out, name, s_suffix, l_suffix, ranges):
+    numshort = 0
+    numlong = 0
+    sptr = "NULL"
+    lptr = "NULL"
+
+    for range in ranges:
+        (low, high) = range
+        if high < 0x10000:
+            if numshort == 0:
+                sptr = name + s_suffix
+                pline = "static const xmlChSRange %s[] = {" % sptr
+            else:
+                pline += ","
+            numshort += 1
+        else:
+            if numlong == 0:
+                if numshort > 0:
+                    out.write(pline + "};\n")
+                lptr = name + l_suffix
+                pline = "static const xmlChLRange %s[] = {" % lptr
+            else:
+                pline += ","
+            numlong += 1
+        if len(pline) > 60:
+            out.write(pline + "\n")
+            pline = "    "
+        elif pline[-1:] == ",":
+            pline += " "
+        pline += "{%s, %s}" % (hex(low), hex(high))
+
+    out.write(pline + "};\n")
+
+    return "{%s,%s,%s,%s}" % (numshort, numlong, sptr, lptr)

codegen/unicode.inc

@@ -0,0 +1,1473 @@
+static const xmlChSRange xmlCS[] = {{0x0, 0x1f}, {0x7f, 0x9f},
+    {0xad, 0xad}, {0x600, 0x603}, {0x6dd, 0x6dd}, {0x70f, 0x70f},
+    {0x17b4, 0x17b5}, {0x200b, 0x200f}, {0x202a, 0x202e}, {0x2060, 0x2063},
+    {0x206a, 0x206f}, {0xd800, 0xd800}, {0xdb7f, 0xdb80}, {0xdbff, 0xdc00},
+    {0xdfff, 0xe000}, {0xf8ff, 0xf8ff}, {0xfeff, 0xfeff}, {0xfff9, 0xfffb}};
+static const xmlChLRange xmlCL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001},
+    {0xe0020, 0xe007f}, {0xf0000, 0xf0000}, {0xffffd, 0xffffd},
+    {0x100000, 0x100000}, {0x10fffd, 0x10fffd}};
+static const xmlChRangeGroup xmlCG = {18,7,xmlCS,xmlCL};
+
+static const xmlChSRange xmlCfS[] = {{0xad, 0xad}, {0x600, 0x603},
+    {0x6dd, 0x6dd}, {0x70f, 0x70f}, {0x17b4, 0x17b5}, {0x200b, 0x200f},
+    {0x202a, 0x202e}, {0x2060, 0x2063}, {0x206a, 0x206f}, {0xfeff, 0xfeff},
+    {0xfff9, 0xfffb}};
+static const xmlChLRange xmlCfL[] = {{0x1d173, 0x1d17a}, {0xe0001, 0xe0001},
+    {0xe0020, 0xe007f}};
+static const xmlChRangeGroup xmlCfG = {11,3,xmlCfS,xmlCfL};
+
+static const xmlChSRange xmlLS[] = {{0x41, 0x5a}, {0x61, 0x7a},
+    {0xaa, 0xaa}, {0xb5, 0xb5}, {0xba, 0xba}, {0xc0, 0xd6}, {0xd8, 0xf6},
+    {0xf8, 0x236}, {0x250, 0x2c1}, {0x2c6, 0x2d1}, {0x2e0, 0x2e4},
+    {0x2ee, 0x2ee}, {0x37a, 0x37a}, {0x386, 0x386}, {0x388, 0x38a},
+    {0x38c, 0x38c}, {0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3f5},
+    {0x3f7, 0x3fb}, {0x400, 0x481}, {0x48a, 0x4ce}, {0x4d0, 0x4f5},
+    {0x4f8, 0x4f9}, {0x500, 0x50f}, {0x531, 0x556}, {0x559, 0x559},
+    {0x561, 0x587}, {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a},
+    {0x640, 0x64a}, {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5},
+    {0x6e5, 0x6e6}, {0x6ee, 0x6ef}, {0x6fa, 0x6fc}, {0x6ff, 0x6ff},
+    {0x710, 0x710}, {0x712, 0x72f}, {0x74d, 0x74f}, {0x780, 0x7a5},
+    {0x7b1, 0x7b1}, {0x904, 0x939}, {0x93d, 0x93d}, {0x950, 0x950},
+    {0x958, 0x961}, {0x985, 0x98c}, {0x98f, 0x990}, {0x993, 0x9a8},
+    {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, {0x9b6, 0x9b9}, {0x9bd, 0x9bd},
+    {0x9dc, 0x9dd}, {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a},
+    {0xa0f, 0xa10}, {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33},
+    {0xa35, 0xa36}, {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e},
+    {0xa72, 0xa74}, {0xa85, 0xa8d}, {0xa8f, 0xa91}, {0xa93, 0xaa8},
+    {0xaaa, 0xab0}, {0xab2, 0xab3}, {0xab5, 0xab9}, {0xabd, 0xabd},
+    {0xad0, 0xad0}, {0xae0, 0xae1}, {0xb05, 0xb0c}, {0xb0f, 0xb10},
+    {0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb35, 0xb39},
+    {0xb3d, 0xb3d}, {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb71, 0xb71},
+    {0xb83, 0xb83}, {0xb85, 0xb8a}, {0xb8e, 0xb90}, {0xb92, 0xb95},
+    {0xb99, 0xb9a}, {0xb9c, 0xb9c}, {0xb9e, 0xb9f}, {0xba3, 0xba4},
+    {0xba8, 0xbaa}, {0xbae, 0xbb5}, {0xbb7, 0xbb9}, {0xc05, 0xc0c},
+    {0xc0e, 0xc10}, {0xc12, 0xc28}, {0xc2a, 0xc33}, {0xc35, 0xc39},
+    {0xc60, 0xc61}, {0xc85, 0xc8c}, {0xc8e, 0xc90}, {0xc92, 0xca8},
+    {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, {0xcbd, 0xcbd}, {0xcde, 0xcde},
+    {0xce0, 0xce1}, {0xd05, 0xd0c}, {0xd0e, 0xd10}, {0xd12, 0xd28},
+    {0xd2a, 0xd39}, {0xd60, 0xd61}, {0xd85, 0xd96}, {0xd9a, 0xdb1},
+    {0xdb3, 0xdbb}, {0xdbd, 0xdbd}, {0xdc0, 0xdc6}, {0xe01, 0xe30},
+    {0xe32, 0xe33}, {0xe40, 0xe46}, {0xe81, 0xe82}, {0xe84, 0xe84},
+    {0xe87, 0xe88}, {0xe8a, 0xe8a}, {0xe8d, 0xe8d}, {0xe94, 0xe97},
+    {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xea5, 0xea5}, {0xea7, 0xea7},
+    {0xeaa, 0xeab}, {0xead, 0xeb0}, {0xeb2, 0xeb3}, {0xebd, 0xebd},
+    {0xec0, 0xec4}, {0xec6, 0xec6}, {0xedc, 0xedd}, {0xf00, 0xf00},
+    {0xf40, 0xf47}, {0xf49, 0xf6a}, {0xf88, 0xf8b}, {0x1000, 0x1021},
+    {0x1023, 0x1027}, {0x1029, 0x102a}, {0x1050, 0x1055}, {0x10a0, 0x10c5},
+    {0x10d0, 0x10f8}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
+    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d},
+    {0x1250, 0x1256}, {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286},
+    {0x1288, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0},
+    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5},
+    {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e},
+    {0x1310, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346},
+    {0x1348, 0x135a}, {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676},
+    {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711},
+    {0x1720, 0x1731}, {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770},
+    {0x1780, 0x17b3}, {0x17d7, 0x17d7}, {0x17dc, 0x17dc}, {0x1820, 0x1877},
+    {0x1880, 0x18a8}, {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974},
+    {0x1d00, 0x1d6b}, {0x1e00, 0x1e9b}, {0x1ea0, 0x1ef9}, {0x1f00, 0x1f15},
+    {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, {0x1f48, 0x1f4d}, {0x1f50, 0x1f57},
+    {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d},
+    {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4},
+    {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, {0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec},
+    {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, {0x2071, 0x2071}, {0x207f, 0x207f},
+    {0x2102, 0x2102}, {0x2107, 0x2107}, {0x210a, 0x2113}, {0x2115, 0x2115},
+    {0x2119, 0x211d}, {0x2124, 0x2124}, {0x2126, 0x2126}, {0x2128, 0x2128},
+    {0x212a, 0x212d}, {0x212f, 0x2131}, {0x2133, 0x2139}, {0x213d, 0x213f},
+    {0x2145, 0x2149}, {0x3005, 0x3006}, {0x3031, 0x3035}, {0x303b, 0x303c},
+    {0x3041, 0x3096}, {0x309d, 0x309f}, {0x30a1, 0x30fa}, {0x30fc, 0x30ff},
+    {0x3105, 0x312c}, {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff},
+    {0x3400, 0x3400}, {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5},
+    {0xa000, 0xa48c}, {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d},
+    {0xfa30, 0xfa6a}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17}, {0xfb1d, 0xfb1d},
+    {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c}, {0xfb3e, 0xfb3e},
+    {0xfb40, 0xfb41}, {0xfb43, 0xfb44}, {0xfb46, 0xfbb1}, {0xfbd3, 0xfd3d},
+    {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb}, {0xfe70, 0xfe74},
+    {0xfe76, 0xfefc}, {0xff21, 0xff3a}, {0xff41, 0xff5a}, {0xff66, 0xffbe},
+    {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc}};
+static const xmlChLRange xmlLL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026},
+    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d},
+    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e},
+    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10400, 0x1049d},
+    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835},
+    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f},
+    {0x1d400, 0x1d454}, {0x1d456, 0x1d49c}, {0x1d49e, 0x1d49f},
+    {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6}, {0x1d4a9, 0x1d4ac},
+    {0x1d4ae, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3},
+    {0x1d4c5, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514},
+    {0x1d516, 0x1d51c}, {0x1d51e, 0x1d539}, {0x1d53b, 0x1d53e},
+    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550},
+    {0x1d552, 0x1d6a3}, {0x1d6a8, 0x1d6c0}, {0x1d6c2, 0x1d6da},
+    {0x1d6dc, 0x1d6fa}, {0x1d6fc, 0x1d714}, {0x1d716, 0x1d734},
+    {0x1d736, 0x1d74e}, {0x1d750, 0x1d76e}, {0x1d770, 0x1d788},
+    {0x1d78a, 0x1d7a8}, {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9},
+    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d}};
+static const xmlChRangeGroup xmlLG = {279,50,xmlLS,xmlLL};
+
+static const xmlChSRange xmlLlS[] = {{0x61, 0x7a}, {0xaa, 0xaa},
+    {0xb5, 0xb5}, {0xba, 0xba}, {0xdf, 0xf6}, {0xf8, 0xff}, {0x101, 0x101},
+    {0x103, 0x103}, {0x105, 0x105}, {0x107, 0x107}, {0x109, 0x109},
+    {0x10b, 0x10b}, {0x10d, 0x10d}, {0x10f, 0x10f}, {0x111, 0x111},
+    {0x113, 0x113}, {0x115, 0x115}, {0x117, 0x117}, {0x119, 0x119},
+    {0x11b, 0x11b}, {0x11d, 0x11d}, {0x11f, 0x11f}, {0x121, 0x121},
+    {0x123, 0x123}, {0x125, 0x125}, {0x127, 0x127}, {0x129, 0x129},
+    {0x12b, 0x12b}, {0x12d, 0x12d}, {0x12f, 0x12f}, {0x131, 0x131},
+    {0x133, 0x133}, {0x135, 0x135}, {0x137, 0x138}, {0x13a, 0x13a},
+    {0x13c, 0x13c}, {0x13e, 0x13e}, {0x140, 0x140}, {0x142, 0x142},
+    {0x144, 0x144}, {0x146, 0x146}, {0x148, 0x149}, {0x14b, 0x14b},
+    {0x14d, 0x14d}, {0x14f, 0x14f}, {0x151, 0x151}, {0x153, 0x153},
+    {0x155, 0x155}, {0x157, 0x157}, {0x159, 0x159}, {0x15b, 0x15b},
+    {0x15d, 0x15d}, {0x15f, 0x15f}, {0x161, 0x161}, {0x163, 0x163},
+    {0x165, 0x165}, {0x167, 0x167}, {0x169, 0x169}, {0x16b, 0x16b},
+    {0x16d, 0x16d}, {0x16f, 0x16f}, {0x171, 0x171}, {0x173, 0x173},
+    {0x175, 0x175}, {0x177, 0x177}, {0x17a, 0x17a}, {0x17c, 0x17c},
+    {0x17e, 0x180}, {0x183, 0x183}, {0x185, 0x185}, {0x188, 0x188},
+    {0x18c, 0x18d}, {0x192, 0x192}, {0x195, 0x195}, {0x199, 0x19b},
+    {0x19e, 0x19e}, {0x1a1, 0x1a1}, {0x1a3, 0x1a3}, {0x1a5, 0x1a5},
+    {0x1a8, 0x1a8}, {0x1aa, 0x1ab}, {0x1ad, 0x1ad}, {0x1b0, 0x1b0},
+    {0x1b4, 0x1b4}, {0x1b6, 0x1b6}, {0x1b9, 0x1ba}, {0x1bd, 0x1bf},
+    {0x1c6, 0x1c6}, {0x1c9, 0x1c9}, {0x1cc, 0x1cc}, {0x1ce, 0x1ce},
+    {0x1d0, 0x1d0}, {0x1d2, 0x1d2}, {0x1d4, 0x1d4}, {0x1d6, 0x1d6},
+    {0x1d8, 0x1d8}, {0x1da, 0x1da}, {0x1dc, 0x1dd}, {0x1df, 0x1df},
+    {0x1e1, 0x1e1}, {0x1e3, 0x1e3}, {0x1e5, 0x1e5}, {0x1e7, 0x1e7},
+    {0x1e9, 0x1e9}, {0x1eb, 0x1eb}, {0x1ed, 0x1ed}, {0x1ef, 0x1f0},
+    {0x1f3, 0x1f3}, {0x1f5, 0x1f5}, {0x1f9, 0x1f9}, {0x1fb, 0x1fb},
+    {0x1fd, 0x1fd}, {0x1ff, 0x1ff}, {0x201, 0x201}, {0x203, 0x203},
+    {0x205, 0x205}, {0x207, 0x207}, {0x209, 0x209}, {0x20b, 0x20b},
+    {0x20d, 0x20d}, {0x20f, 0x20f}, {0x211, 0x211}, {0x213, 0x213},
+    {0x215, 0x215}, {0x217, 0x217}, {0x219, 0x219}, {0x21b, 0x21b},
+    {0x21d, 0x21d}, {0x21f, 0x21f}, {0x221, 0x221}, {0x223, 0x223},
+    {0x225, 0x225}, {0x227, 0x227}, {0x229, 0x229}, {0x22b, 0x22b},
+    {0x22d, 0x22d}, {0x22f, 0x22f}, {0x231, 0x231}, {0x233, 0x236},
+    {0x250, 0x2af}, {0x390, 0x390}, {0x3ac, 0x3ce}, {0x3d0, 0x3d1},
+    {0x3d5, 0x3d7}, {0x3d9, 0x3d9}, {0x3db, 0x3db}, {0x3dd, 0x3dd},
+    {0x3df, 0x3df}, {0x3e1, 0x3e1}, {0x3e3, 0x3e3}, {0x3e5, 0x3e5},
+    {0x3e7, 0x3e7}, {0x3e9, 0x3e9}, {0x3eb, 0x3eb}, {0x3ed, 0x3ed},
+    {0x3ef, 0x3f3}, {0x3f5, 0x3f5}, {0x3f8, 0x3f8}, {0x3fb, 0x3fb},
+    {0x430, 0x45f}, {0x461, 0x461}, {0x463, 0x463}, {0x465, 0x465},
+    {0x467, 0x467}, {0x469, 0x469}, {0x46b, 0x46b}, {0x46d, 0x46d},
+    {0x46f, 0x46f}, {0x471, 0x471}, {0x473, 0x473}, {0x475, 0x475},
+    {0x477, 0x477}, {0x479, 0x479}, {0x47b, 0x47b}, {0x47d, 0x47d},
+    {0x47f, 0x47f}, {0x481, 0x481}, {0x48b, 0x48b}, {0x48d, 0x48d},
+    {0x48f, 0x48f}, {0x491, 0x491}, {0x493, 0x493}, {0x495, 0x495},
+    {0x497, 0x497}, {0x499, 0x499}, {0x49b, 0x49b}, {0x49d, 0x49d},
+    {0x49f, 0x49f}, {0x4a1, 0x4a1}, {0x4a3, 0x4a3}, {0x4a5, 0x4a5},
+    {0x4a7, 0x4a7}, {0x4a9, 0x4a9}, {0x4ab, 0x4ab}, {0x4ad, 0x4ad},
+    {0x4af, 0x4af}, {0x4b1, 0x4b1}, {0x4b3, 0x4b3}, {0x4b5, 0x4b5},
+    {0x4b7, 0x4b7}, {0x4b9, 0x4b9}, {0x4bb, 0x4bb}, {0x4bd, 0x4bd},
+    {0x4bf, 0x4bf}, {0x4c2, 0x4c2}, {0x4c4, 0x4c4}, {0x4c6, 0x4c6},
+    {0x4c8, 0x4c8}, {0x4ca, 0x4ca}, {0x4cc, 0x4cc}, {0x4ce, 0x4ce},
+    {0x4d1, 0x4d1}, {0x4d3, 0x4d3}, {0x4d5, 0x4d5}, {0x4d7, 0x4d7},
+    {0x4d9, 0x4d9}, {0x4db, 0x4db}, {0x4dd, 0x4dd}, {0x4df, 0x4df},
+    {0x4e1, 0x4e1}, {0x4e3, 0x4e3}, {0x4e5, 0x4e5}, {0x4e7, 0x4e7},
+    {0x4e9, 0x4e9}, {0x4eb, 0x4eb}, {0x4ed, 0x4ed}, {0x4ef, 0x4ef},
+    {0x4f1, 0x4f1}, {0x4f3, 0x4f3}, {0x4f5, 0x4f5}, {0x4f9, 0x4f9},
+    {0x501, 0x501}, {0x503, 0x503}, {0x505, 0x505}, {0x507, 0x507},
+    {0x509, 0x509}, {0x50b, 0x50b}, {0x50d, 0x50d}, {0x50f, 0x50f},
+    {0x561, 0x587}, {0x1d00, 0x1d2b}, {0x1d62, 0x1d6b}, {0x1e01, 0x1e01},
+    {0x1e03, 0x1e03}, {0x1e05, 0x1e05}, {0x1e07, 0x1e07}, {0x1e09, 0x1e09},
+    {0x1e0b, 0x1e0b}, {0x1e0d, 0x1e0d}, {0x1e0f, 0x1e0f}, {0x1e11, 0x1e11},
+    {0x1e13, 0x1e13}, {0x1e15, 0x1e15}, {0x1e17, 0x1e17}, {0x1e19, 0x1e19},
+    {0x1e1b, 0x1e1b}, {0x1e1d, 0x1e1d}, {0x1e1f, 0x1e1f}, {0x1e21, 0x1e21},
+    {0x1e23, 0x1e23}, {0x1e25, 0x1e25}, {0x1e27, 0x1e27}, {0x1e29, 0x1e29},
+    {0x1e2b, 0x1e2b}, {0x1e2d, 0x1e2d}, {0x1e2f, 0x1e2f}, {0x1e31, 0x1e31},
+    {0x1e33, 0x1e33}, {0x1e35, 0x1e35}, {0x1e37, 0x1e37}, {0x1e39, 0x1e39},
+    {0x1e3b, 0x1e3b}, {0x1e3d, 0x1e3d}, {0x1e3f, 0x1e3f}, {0x1e41, 0x1e41},
+    {0x1e43, 0x1e43}, {0x1e45, 0x1e45}, {0x1e47, 0x1e47}, {0x1e49, 0x1e49},
+    {0x1e4b, 0x1e4b}, {0x1e4d, 0x1e4d}, {0x1e4f, 0x1e4f}, {0x1e51, 0x1e51},
+    {0x1e53, 0x1e53}, {0x1e55, 0x1e55}, {0x1e57, 0x1e57}, {0x1e59, 0x1e59},
+    {0x1e5b, 0x1e5b}, {0x1e5d, 0x1e5d}, {0x1e5f, 0x1e5f}, {0x1e61, 0x1e61},
+    {0x1e63, 0x1e63}, {0x1e65, 0x1e65}, {0x1e67, 0x1e67}, {0x1e69, 0x1e69},
+    {0x1e6b, 0x1e6b}, {0x1e6d, 0x1e6d}, {0x1e6f, 0x1e6f}, {0x1e71, 0x1e71},
+    {0x1e73, 0x1e73}, {0x1e75, 0x1e75}, {0x1e77, 0x1e77}, {0x1e79, 0x1e79},
+    {0x1e7b, 0x1e7b}, {0x1e7d, 0x1e7d}, {0x1e7f, 0x1e7f}, {0x1e81, 0x1e81},
+    {0x1e83, 0x1e83}, {0x1e85, 0x1e85}, {0x1e87, 0x1e87}, {0x1e89, 0x1e89},
+    {0x1e8b, 0x1e8b}, {0x1e8d, 0x1e8d}, {0x1e8f, 0x1e8f}, {0x1e91, 0x1e91},
+    {0x1e93, 0x1e93}, {0x1e95, 0x1e9b}, {0x1ea1, 0x1ea1}, {0x1ea3, 0x1ea3},
+    {0x1ea5, 0x1ea5}, {0x1ea7, 0x1ea7}, {0x1ea9, 0x1ea9}, {0x1eab, 0x1eab},
+    {0x1ead, 0x1ead}, {0x1eaf, 0x1eaf}, {0x1eb1, 0x1eb1}, {0x1eb3, 0x1eb3},
+    {0x1eb5, 0x1eb5}, {0x1eb7, 0x1eb7}, {0x1eb9, 0x1eb9}, {0x1ebb, 0x1ebb},
+    {0x1ebd, 0x1ebd}, {0x1ebf, 0x1ebf}, {0x1ec1, 0x1ec1}, {0x1ec3, 0x1ec3},
+    {0x1ec5, 0x1ec5}, {0x1ec7, 0x1ec7}, {0x1ec9, 0x1ec9}, {0x1ecb, 0x1ecb},
+    {0x1ecd, 0x1ecd}, {0x1ecf, 0x1ecf}, {0x1ed1, 0x1ed1}, {0x1ed3, 0x1ed3},
+    {0x1ed5, 0x1ed5}, {0x1ed7, 0x1ed7}, {0x1ed9, 0x1ed9}, {0x1edb, 0x1edb},
+    {0x1edd, 0x1edd}, {0x1edf, 0x1edf}, {0x1ee1, 0x1ee1}, {0x1ee3, 0x1ee3},
+    {0x1ee5, 0x1ee5}, {0x1ee7, 0x1ee7}, {0x1ee9, 0x1ee9}, {0x1eeb, 0x1eeb},
+    {0x1eed, 0x1eed}, {0x1eef, 0x1eef}, {0x1ef1, 0x1ef1}, {0x1ef3, 0x1ef3},
+    {0x1ef5, 0x1ef5}, {0x1ef7, 0x1ef7}, {0x1ef9, 0x1ef9}, {0x1f00, 0x1f07},
+    {0x1f10, 0x1f15}, {0x1f20, 0x1f27}, {0x1f30, 0x1f37}, {0x1f40, 0x1f45},
+    {0x1f50, 0x1f57}, {0x1f60, 0x1f67}, {0x1f70, 0x1f7d}, {0x1f80, 0x1f87},
+    {0x1f90, 0x1f97}, {0x1fa0, 0x1fa7}, {0x1fb0, 0x1fb4}, {0x1fb6, 0x1fb7},
+    {0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fc7}, {0x1fd0, 0x1fd3},
+    {0x1fd6, 0x1fd7}, {0x1fe0, 0x1fe7}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ff7},
+    {0x2071, 0x2071}, {0x207f, 0x207f}, {0x210a, 0x210a}, {0x210e, 0x210f},
+    {0x2113, 0x2113}, {0x212f, 0x212f}, {0x2134, 0x2134}, {0x2139, 0x2139},
+    {0x213d, 0x213d}, {0x2146, 0x2149}, {0xfb00, 0xfb06}, {0xfb13, 0xfb17},
+    {0xff41, 0xff5a}};
+static const xmlChLRange xmlLlL[] = {{0x10428, 0x1044f}, {0x1d41a, 0x1d433},
+    {0x1d44e, 0x1d454}, {0x1d456, 0x1d467}, {0x1d482, 0x1d49b},
+    {0x1d4b6, 0x1d4b9}, {0x1d4bb, 0x1d4bb}, {0x1d4bd, 0x1d4c3},
+    {0x1d4c5, 0x1d4cf}, {0x1d4ea, 0x1d503}, {0x1d51e, 0x1d537},
+    {0x1d552, 0x1d56b}, {0x1d586, 0x1d59f}, {0x1d5ba, 0x1d5d3},
+    {0x1d5ee, 0x1d607}, {0x1d622, 0x1d63b}, {0x1d656, 0x1d66f},
+    {0x1d68a, 0x1d6a3}, {0x1d6c2, 0x1d6da}, {0x1d6dc, 0x1d6e1},
+    {0x1d6fc, 0x1d714}, {0x1d716, 0x1d71b}, {0x1d736, 0x1d74e},
+    {0x1d750, 0x1d755}, {0x1d770, 0x1d788}, {0x1d78a, 0x1d78f},
+    {0x1d7aa, 0x1d7c2}, {0x1d7c4, 0x1d7c9}};
+static const xmlChRangeGroup xmlLlG = {396,28,xmlLlS,xmlLlL};
+
+static const xmlChSRange xmlLmS[] = {{0x2b0, 0x2c1}, {0x2c6, 0x2d1},
+    {0x2e0, 0x2e4}, {0x2ee, 0x2ee}, {0x37a, 0x37a}, {0x559, 0x559},
+    {0x640, 0x640}, {0x6e5, 0x6e6}, {0xe46, 0xe46}, {0xec6, 0xec6},
+    {0x17d7, 0x17d7}, {0x1843, 0x1843}, {0x1d2c, 0x1d61}, {0x3005, 0x3005},
+    {0x3031, 0x3035}, {0x303b, 0x303b}, {0x309d, 0x309e}, {0x30fc, 0x30fe},
+    {0xff70, 0xff70}, {0xff9e, 0xff9f}};
+static const xmlChRangeGroup xmlLmG = {20,0,xmlLmS,NULL};
+
+static const xmlChSRange xmlLoS[] = {{0x1bb, 0x1bb}, {0x1c0, 0x1c3},
+    {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, {0x641, 0x64a},
+    {0x66e, 0x66f}, {0x671, 0x6d3}, {0x6d5, 0x6d5}, {0x6ee, 0x6ef},
+    {0x6fa, 0x6fc}, {0x6ff, 0x6ff}, {0x710, 0x710}, {0x712, 0x72f},
+    {0x74d, 0x74f}, {0x780, 0x7a5}, {0x7b1, 0x7b1}, {0x904, 0x939},
+    {0x93d, 0x93d}, {0x950, 0x950}, {0x958, 0x961}, {0x985, 0x98c},
+    {0x98f, 0x990}, {0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2},
+    {0x9b6, 0x9b9}, {0x9bd, 0x9bd}, {0x9dc, 0x9dd}, {0x9df, 0x9e1},
+    {0x9f0, 0x9f1}, {0xa05, 0xa0a}, {0xa0f, 0xa10}, {0xa13, 0xa28},
+    {0xa2a, 0xa30}, {0xa32, 0xa33}, {0xa35, 0xa36}, {0xa38, 0xa39},
+    {0xa59, 0xa5c}, {0xa5e, 0xa5e}, {0xa72, 0xa74}, {0xa85, 0xa8d},
+    {0xa8f, 0xa91}, {0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3},
+    {0xab5, 0xab9}, {0xabd, 0xabd}, {0xad0, 0xad0}, {0xae0, 0xae1},
+    {0xb05, 0xb0c}, {0xb0f, 0xb10}, {0xb13, 0xb28}, {0xb2a, 0xb30},
+    {0xb32, 0xb33}, {0xb35, 0xb39}, {0xb3d, 0xb3d}, {0xb5c, 0xb5d},
+    {0xb5f, 0xb61}, {0xb71, 0xb71}, {0xb83, 0xb83}, {0xb85, 0xb8a},
+    {0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c},
+    {0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5},
+    {0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28},
+    {0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c},
+    {0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9},
+    {0xcbd, 0xcbd}, {0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c},
+    {0xd0e, 0xd10}, {0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61},
+    {0xd85, 0xd96}, {0xd9a, 0xdb1}, {0xdb3, 0xdbb}, {0xdbd, 0xdbd},
+    {0xdc0, 0xdc6}, {0xe01, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45},
+    {0xe81, 0xe82}, {0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a},
+    {0xe8d, 0xe8d}, {0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3},
+    {0xea5, 0xea5}, {0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeb0},
+    {0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, {0xedc, 0xedd},
+    {0xf00, 0xf00}, {0xf40, 0xf47}, {0xf49, 0xf6a}, {0xf88, 0xf8b},
+    {0x1000, 0x1021}, {0x1023, 0x1027}, {0x1029, 0x102a}, {0x1050, 0x1055},
+    {0x10d0, 0x10f8}, {0x1100, 0x1159}, {0x115f, 0x11a2}, {0x11a8, 0x11f9},
+    {0x1200, 0x1206}, {0x1208, 0x1246}, {0x1248, 0x1248}, {0x124a, 0x124d},
+    {0x1250, 0x1256}, {0x1258, 0x1258}, {0x125a, 0x125d}, {0x1260, 0x1286},
+    {0x1288, 0x1288}, {0x128a, 0x128d}, {0x1290, 0x12ae}, {0x12b0, 0x12b0},
+    {0x12b2, 0x12b5}, {0x12b8, 0x12be}, {0x12c0, 0x12c0}, {0x12c2, 0x12c5},
+    {0x12c8, 0x12ce}, {0x12d0, 0x12d6}, {0x12d8, 0x12ee}, {0x12f0, 0x130e},
+    {0x1310, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x131e}, {0x1320, 0x1346},
+    {0x1348, 0x135a}, {0x13a0, 0x13f4}, {0x1401, 0x166c}, {0x166f, 0x1676},
+    {0x1681, 0x169a}, {0x16a0, 0x16ea}, {0x1700, 0x170c}, {0x170e, 0x1711},
+    {0x1720, 0x1731}, {0x1740, 0x1751}, {0x1760, 0x176c}, {0x176e, 0x1770},
+    {0x1780, 0x17b3}, {0x17dc, 0x17dc}, {0x1820, 0x1842}, {0x1844, 0x1877},
+    {0x1880, 0x18a8}, {0x1900, 0x191c}, {0x1950, 0x196d}, {0x1970, 0x1974},
+    {0x2135, 0x2138}, {0x3006, 0x3006}, {0x303c, 0x303c}, {0x3041, 0x3096},
+    {0x309f, 0x309f}, {0x30a1, 0x30fa}, {0x30ff, 0x30ff}, {0x3105, 0x312c},
+    {0x3131, 0x318e}, {0x31a0, 0x31b7}, {0x31f0, 0x31ff}, {0x3400, 0x3400},
+    {0x4db5, 0x4db5}, {0x4e00, 0x4e00}, {0x9fa5, 0x9fa5}, {0xa000, 0xa48c},
+    {0xac00, 0xac00}, {0xd7a3, 0xd7a3}, {0xf900, 0xfa2d}, {0xfa30, 0xfa6a},
+    {0xfb1d, 0xfb1d}, {0xfb1f, 0xfb28}, {0xfb2a, 0xfb36}, {0xfb38, 0xfb3c},
+    {0xfb3e, 0xfb3e}, {0xfb40, 0xfb41}, {0xfb43, 0xfb44}, {0xfb46, 0xfbb1},
+    {0xfbd3, 0xfd3d}, {0xfd50, 0xfd8f}, {0xfd92, 0xfdc7}, {0xfdf0, 0xfdfb},
+    {0xfe70, 0xfe74}, {0xfe76, 0xfefc}, {0xff66, 0xff6f}, {0xff71, 0xff9d},
+    {0xffa0, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7},
+    {0xffda, 0xffdc}};
+static const xmlChLRange xmlLoL[] = {{0x10000, 0x1000b}, {0x1000d, 0x10026},
+    {0x10028, 0x1003a}, {0x1003c, 0x1003d}, {0x1003f, 0x1004d},
+    {0x10050, 0x1005d}, {0x10080, 0x100fa}, {0x10300, 0x1031e},
+    {0x10330, 0x10349}, {0x10380, 0x1039d}, {0x10450, 0x1049d},
+    {0x10800, 0x10805}, {0x10808, 0x10808}, {0x1080a, 0x10835},
+    {0x10837, 0x10838}, {0x1083c, 0x1083c}, {0x1083f, 0x1083f},
+    {0x20000, 0x20000}, {0x2a6d6, 0x2a6d6}, {0x2f800, 0x2fa1d}};
+static const xmlChRangeGroup xmlLoG = {211,20,xmlLoS,xmlLoL};
+
+static const xmlChSRange xmlLtS[] = {{0x1c5, 0x1c5}, {0x1c8, 0x1c8},
+    {0x1cb, 0x1cb}, {0x1f2, 0x1f2}, {0x1f88, 0x1f8f}, {0x1f98, 0x1f9f},
+    {0x1fa8, 0x1faf}, {0x1fbc, 0x1fbc}, {0x1fcc, 0x1fcc}, {0x1ffc, 0x1ffc}};
+static const xmlChRangeGroup xmlLtG = {10,0,xmlLtS,NULL};
+
+static const xmlChSRange xmlLuS[] = {{0x41, 0x5a}, {0xc0, 0xd6},
+    {0xd8, 0xde}, {0x100, 0x100}, {0x102, 0x102}, {0x104, 0x104},
+    {0x106, 0x106}, {0x108, 0x108}, {0x10a, 0x10a}, {0x10c, 0x10c},
+    {0x10e, 0x10e}, {0x110, 0x110}, {0x112, 0x112}, {0x114, 0x114},
+    {0x116, 0x116}, {0x118, 0x118}, {0x11a, 0x11a}, {0x11c, 0x11c},
+    {0x11e, 0x11e}, {0x120, 0x120}, {0x122, 0x122}, {0x124, 0x124},
+    {0x126, 0x126}, {0x128, 0x128}, {0x12a, 0x12a}, {0x12c, 0x12c},
+    {0x12e, 0x12e}, {0x130, 0x130}, {0x132, 0x132}, {0x134, 0x134},
+    {0x136, 0x136}, {0x139, 0x139}, {0x13b, 0x13b}, {0x13d, 0x13d},
+    {0x13f, 0x13f}, {0x141, 0x141}, {0x143, 0x143}, {0x145, 0x145},
+    {0x147, 0x147}, {0x14a, 0x14a}, {0x14c, 0x14c}, {0x14e, 0x14e},
+    {0x150, 0x150}, {0x152, 0x152}, {0x154, 0x154}, {0x156, 0x156},
+    {0x158, 0x158}, {0x15a, 0x15a}, {0x15c, 0x15c}, {0x15e, 0x15e},
+    {0x160, 0x160}, {0x162, 0x162}, {0x164, 0x164}, {0x166, 0x166},
+    {0x168, 0x168}, {0x16a, 0x16a}, {0x16c, 0x16c}, {0x16e, 0x16e},
+    {0x170, 0x170}, {0x172, 0x172}, {0x174, 0x174}, {0x176, 0x176},
+    {0x178, 0x179}, {0x17b, 0x17b}, {0x17d, 0x17d}, {0x181, 0x182},
+    {0x184, 0x184}, {0x186, 0x187}, {0x189, 0x18b}, {0x18e, 0x191},
+    {0x193, 0x194}, {0x196, 0x198}, {0x19c, 0x19d}, {0x19f, 0x1a0},
+    {0x1a2, 0x1a2}, {0x1a4, 0x1a4}, {0x1a6, 0x1a7}, {0x1a9, 0x1a9},
+    {0x1ac, 0x1ac}, {0x1ae, 0x1af}, {0x1b1, 0x1b3}, {0x1b5, 0x1b5},
+    {0x1b7, 0x1b8}, {0x1bc, 0x1bc}, {0x1c4, 0x1c4}, {0x1c7, 0x1c7},
+    {0x1ca, 0x1ca}, {0x1cd, 0x1cd}, {0x1cf, 0x1cf}, {0x1d1, 0x1d1},
+    {0x1d3, 0x1d3}, {0x1d5, 0x1d5}, {0x1d7, 0x1d7}, {0x1d9, 0x1d9},
+    {0x1db, 0x1db}, {0x1de, 0x1de}, {0x1e0, 0x1e0}, {0x1e2, 0x1e2},
+    {0x1e4, 0x1e4}, {0x1e6, 0x1e6}, {0x1e8, 0x1e8}, {0x1ea, 0x1ea},
+    {0x1ec, 0x1ec}, {0x1ee, 0x1ee}, {0x1f1, 0x1f1}, {0x1f4, 0x1f4},
+    {0x1f6, 0x1f8}, {0x1fa, 0x1fa}, {0x1fc, 0x1fc}, {0x1fe, 0x1fe},
+    {0x200, 0x200}, {0x202, 0x202}, {0x204, 0x204}, {0x206, 0x206},
+    {0x208, 0x208}, {0x20a, 0x20a}, {0x20c, 0x20c}, {0x20e, 0x20e},
+    {0x210, 0x210}, {0x212, 0x212}, {0x214, 0x214}, {0x216, 0x216},
+    {0x218, 0x218}, {0x21a, 0x21a}, {0x21c, 0x21c}, {0x21e, 0x21e},
+    {0x220, 0x220}, {0x222, 0x222}, {0x224, 0x224}, {0x226, 0x226},
+    {0x228, 0x228}, {0x22a, 0x22a}, {0x22c, 0x22c}, {0x22e, 0x22e},
+    {0x230, 0x230}, {0x232, 0x232}, {0x386, 0x386}, {0x388, 0x38a},
+    {0x38c, 0x38c}, {0x38e, 0x38f}, {0x391, 0x3a1}, {0x3a3, 0x3ab},
+    {0x3d2, 0x3d4}, {0x3d8, 0x3d8}, {0x3da, 0x3da}, {0x3dc, 0x3dc},
+    {0x3de, 0x3de}, {0x3e0, 0x3e0}, {0x3e2, 0x3e2}, {0x3e4, 0x3e4},
+    {0x3e6, 0x3e6}, {0x3e8, 0x3e8}, {0x3ea, 0x3ea}, {0x3ec, 0x3ec},
+    {0x3ee, 0x3ee}, {0x3f4, 0x3f4}, {0x3f7, 0x3f7}, {0x3f9, 0x3fa},
+    {0x400, 0x42f}, {0x460, 0x460}, {0x462, 0x462}, {0x464, 0x464},
+    {0x466, 0x466}, {0x468, 0x468}, {0x46a, 0x46a}, {0x46c, 0x46c},
+    {0x46e, 0x46e}, {0x470, 0x470}, {0x472, 0x472}, {0x474, 0x474},
+    {0x476, 0x476}, {0x478, 0x478}, {0x47a, 0x47a}, {0x47c, 0x47c},
+    {0x47e, 0x47e}, {0x480, 0x480}, {0x48a, 0x48a}, {0x48c, 0x48c},
+    {0x48e, 0x48e}, {0x490, 0x490}, {0x492, 0x492}, {0x494, 0x494},
+    {0x496, 0x496}, {0x498, 0x498}, {0x49a, 0x49a}, {0x49c, 0x49c},
+    {0x49e, 0x49e}, {0x4a0, 0x4a0}, {0x4a2, 0x4a2}, {0x4a4, 0x4a4},
+    {0x4a6, 0x4a6}, {0x4a8, 0x4a8}, {0x4aa, 0x4aa}, {0x4ac, 0x4ac},
+    {0x4ae, 0x4ae}, {0x4b0, 0x4b0}, {0x4b2, 0x4b2}, {0x4b4, 0x4b4},
+    {0x4b6, 0x4b6}, {0x4b8, 0x4b8}, {0x4ba, 0x4ba}, {0x4bc, 0x4bc},
+    {0x4be, 0x4be}, {0x4c0, 0x4c1}, {0x4c3, 0x4c3}, {0x4c5, 0x4c5},
+    {0x4c7, 0x4c7}, {0x4c9, 0x4c9}, {0x4cb, 0x4cb}, {0x4cd, 0x4cd},
+    {0x4d0, 0x4d0}, {0x4d2, 0x4d2}, {0x4d4, 0x4d4}, {0x4d6, 0x4d6},
+    {0x4d8, 0x4d8}, {0x4da, 0x4da}, {0x4dc, 0x4dc}, {0x4de, 0x4de},
+    {0x4e0, 0x4e0}, {0x4e2, 0x4e2}, {0x4e4, 0x4e4}, {0x4e6, 0x4e6},
+    {0x4e8, 0x4e8}, {0x4ea, 0x4ea}, {0x4ec, 0x4ec}, {0x4ee, 0x4ee},
+    {0x4f0, 0x4f0}, {0x4f2, 0x4f2}, {0x4f4, 0x4f4}, {0x4f8, 0x4f8},
+    {0x500, 0x500}, {0x502, 0x502}, {0x504, 0x504}, {0x506, 0x506},
+    {0x508, 0x508}, {0x50a, 0x50a}, {0x50c, 0x50c}, {0x50e, 0x50e},
+    {0x531, 0x556}, {0x10a0, 0x10c5}, {0x1e00, 0x1e00}, {0x1e02, 0x1e02},
+    {0x1e04, 0x1e04}, {0x1e06, 0x1e06}, {0x1e08, 0x1e08}, {0x1e0a, 0x1e0a},
+    {0x1e0c, 0x1e0c}, {0x1e0e, 0x1e0e}, {0x1e10, 0x1e10}, {0x1e12, 0x1e12},
+    {0x1e14, 0x1e14}, {0x1e16, 0x1e16}, {0x1e18, 0x1e18}, {0x1e1a, 0x1e1a},
+    {0x1e1c, 0x1e1c}, {0x1e1e, 0x1e1e}, {0x1e20, 0x1e20}, {0x1e22, 0x1e22},
+    {0x1e24, 0x1e24}, {0x1e26, 0x1e26}, {0x1e28, 0x1e28}, {0x1e2a, 0x1e2a},
+    {0x1e2c, 0x1e2c}, {0x1e2e, 0x1e2e}, {0x1e30, 0x1e30}, {0x1e32, 0x1e32},
+    {0x1e34, 0x1e34}, {0x1e36, 0x1e36}, {0x1e38, 0x1e38}, {0x1e3a, 0x1e3a},
+    {0x1e3c, 0x1e3c}, {0x1e3e, 0x1e3e}, {0x1e40, 0x1e40}, {0x1e42, 0x1e42},
+    {0x1e44, 0x1e44}, {0x1e46, 0x1e46}, {0x1e48, 0x1e48}, {0x1e4a, 0x1e4a},
+    {0x1e4c, 0x1e4c}, {0x1e4e, 0x1e4e}, {0x1e50, 0x1e50}, {0x1e52, 0x1e52},
+    {0x1e54, 0x1e54}, {0x1e56, 0x1e56}, {0x1e58, 0x1e58}, {0x1e5a, 0x1e5a},
+    {0x1e5c, 0x1e5c}, {0x1e5e, 0x1e5e}, {0x1e60, 0x1e60}, {0x1e62, 0x1e62},
+    {0x1e64, 0x1e64}, {0x1e66, 0x1e66}, {0x1e68, 0x1e68}, {0x1e6a, 0x1e6a},
+    {0x1e6c, 0x1e6c}, {0x1e6e, 0x1e6e}, {0x1e70, 0x1e70}, {0x1e72, 0x1e72},
+    {0x1e74, 0x1e74}, {0x1e76, 0x1e76}, {0x1e78, 0x1e78}, {0x1e7a, 0x1e7a},
+    {0x1e7c, 0x1e7c}, {0x1e7e, 0x1e7e}, {0x1e80, 0x1e80}, {0x1e82, 0x1e82},
+    {0x1e84, 0x1e84}, {0x1e86, 0x1e86}, {0x1e88, 0x1e88}, {0x1e8a, 0x1e8a},
+    {0x1e8c, 0x1e8c}, {0x1e8e, 0x1e8e}, {0x1e90, 0x1e90}, {0x1e92, 0x1e92},
+    {0x1e94, 0x1e94}, {0x1ea0, 0x1ea0}, {0x1ea2, 0x1ea2}, {0x1ea4, 0x1ea4},
+    {0x1ea6, 0x1ea6}, {0x1ea8, 0x1ea8}, {0x1eaa, 0x1eaa}, {0x1eac, 0x1eac},
+    {0x1eae, 0x1eae}, {0x1eb0, 0x1eb0}, {0x1eb2, 0x1eb2}, {0x1eb4, 0x1eb4},
+    {0x1eb6, 0x1eb6}, {0x1eb8, 0x1eb8}, {0x1eba, 0x1eba}, {0x1ebc, 0x1ebc},
+    {0x1ebe, 0x1ebe}, {0x1ec0, 0x1ec0}, {0x1ec2, 0x1ec2}, {0x1ec4, 0x1ec4},
+    {0x1ec6, 0x1ec6}, {0x1ec8, 0x1ec8}, {0x1eca, 0x1eca}, {0x1ecc, 0x1ecc},
+    {0x1ece, 0x1ece}, {0x1ed0, 0x1ed0}, {0x1ed2, 0x1ed2}, {0x1ed4, 0x1ed4},
+    {0x1ed6, 0x1ed6}, {0x1ed8, 0x1ed8}, {0x1eda, 0x1eda}, {0x1edc, 0x1edc},
+    {0x1ede, 0x1ede}, {0x1ee0, 0x1ee0}, {0x1ee2, 0x1ee2}, {0x1ee4, 0x1ee4},
+    {0x1ee6, 0x1ee6}, {0x1ee8, 0x1ee8}, {0x1eea, 0x1eea}, {0x1eec, 0x1eec},
+    {0x1eee, 0x1eee}, {0x1ef0, 0x1ef0}, {0x1ef2, 0x1ef2}, {0x1ef4, 0x1ef4},
+    {0x1ef6, 0x1ef6}, {0x1ef8, 0x1ef8}, {0x1f08, 0x1f0f}, {0x1f18, 0x1f1d},
+    {0x1f28, 0x1f2f}, {0x1f38, 0x1f3f}, {0x1f48, 0x1f4d}, {0x1f59, 0x1f59},
+    {0x1f5b, 0x1f5b}, {0x1f5d, 0x1f5d}, {0x1f5f, 0x1f5f}, {0x1f68, 0x1f6f},
+    {0x1fb8, 0x1fbb}, {0x1fc8, 0x1fcb}, {0x1fd8, 0x1fdb}, {0x1fe8, 0x1fec},
+    {0x1ff8, 0x1ffb}, {0x2102, 0x2102}, {0x2107, 0x2107}, {0x210b, 0x210d},
+    {0x2110, 0x2112}, {0x2115, 0x2115}, {0x2119, 0x211d}, {0x2124, 0x2124},
+    {0x2126, 0x2126}, {0x2128, 0x2128}, {0x212a, 0x212d}, {0x2130, 0x2131},
+    {0x2133, 0x2133}, {0x213e, 0x213f}, {0x2145, 0x2145}, {0xff21, 0xff3a}};
+static const xmlChLRange xmlLuL[] = {{0x10400, 0x10427}, {0x1d400, 0x1d419},
+    {0x1d434, 0x1d44d}, {0x1d468, 0x1d481}, {0x1d49c, 0x1d49c},
+    {0x1d49e, 0x1d49f}, {0x1d4a2, 0x1d4a2}, {0x1d4a5, 0x1d4a6},
+    {0x1d4a9, 0x1d4ac}, {0x1d4ae, 0x1d4b5}, {0x1d4d0, 0x1d4e9},
+    {0x1d504, 0x1d505}, {0x1d507, 0x1d50a}, {0x1d50d, 0x1d514},
+    {0x1d516, 0x1d51c}, {0x1d538, 0x1d539}, {0x1d53b, 0x1d53e},
+    {0x1d540, 0x1d544}, {0x1d546, 0x1d546}, {0x1d54a, 0x1d550},
+    {0x1d56c, 0x1d585}, {0x1d5a0, 0x1d5b9}, {0x1d5d4, 0x1d5ed},
+    {0x1d608, 0x1d621}, {0x1d63c, 0x1d655}, {0x1d670, 0x1d689},
+    {0x1d6a8, 0x1d6c0}, {0x1d6e2, 0x1d6fa}, {0x1d71c, 0x1d734},
+    {0x1d756, 0x1d76e}, {0x1d790, 0x1d7a8}};
+static const xmlChRangeGroup xmlLuG = {390,31,xmlLuS,xmlLuL};
+
+static const xmlChSRange xmlMS[] = {{0x300, 0x357}, {0x35d, 0x36f},
+    {0x483, 0x486}, {0x488, 0x489}, {0x591, 0x5a1}, {0x5a3, 0x5b9},
+    {0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4},
+    {0x610, 0x615}, {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc},
+    {0x6de, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711},
+    {0x730, 0x74a}, {0x7a6, 0x7b0}, {0x901, 0x903}, {0x93c, 0x93c},
+    {0x93e, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x983},
+    {0x9bc, 0x9bc}, {0x9be, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd},
+    {0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa01, 0xa03}, {0xa3c, 0xa3c},
+    {0xa3e, 0xa42}, {0xa47, 0xa48}, {0xa4b, 0xa4d}, {0xa70, 0xa71},
+    {0xa81, 0xa83}, {0xabc, 0xabc}, {0xabe, 0xac5}, {0xac7, 0xac9},
+    {0xacb, 0xacd}, {0xae2, 0xae3}, {0xb01, 0xb03}, {0xb3c, 0xb3c},
+    {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, {0xb56, 0xb57},
+    {0xb82, 0xb82}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, {0xbca, 0xbcd},
+    {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, {0xc46, 0xc48},
+    {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, {0xcbc, 0xcbc},
+    {0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6},
+    {0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d},
+    {0xd57, 0xd57}, {0xd82, 0xd83}, {0xdca, 0xdca}, {0xdcf, 0xdd4},
+    {0xdd6, 0xdd6}, {0xdd8, 0xddf}, {0xdf2, 0xdf3}, {0xe31, 0xe31},
+    {0xe34, 0xe3a}, {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9},
+    {0xebb, 0xebc}, {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35},
+    {0xf37, 0xf37}, {0xf39, 0xf39}, {0xf3e, 0xf3f}, {0xf71, 0xf84},
+    {0xf86, 0xf87}, {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6},
+    {0x102c, 0x1032}, {0x1036, 0x1039}, {0x1056, 0x1059}, {0x1712, 0x1714},
+    {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773}, {0x17b6, 0x17d3},
+    {0x17dd, 0x17dd}, {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x192b},
+    {0x1930, 0x193b}, {0x20d0, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a},
+    {0xfb1e, 0xfb1e}, {0xfe00, 0xfe0f}, {0xfe20, 0xfe23}};
+static const xmlChLRange xmlML[] = {{0x1d165, 0x1d169}, {0x1d16d, 0x1d172},
+    {0x1d17b, 0x1d182}, {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad},
+    {0xe0100, 0xe01ef}};
+static const xmlChRangeGroup xmlMG = {113,6,xmlMS,xmlML};
+
+static const xmlChSRange xmlMcS[] = {{0x903, 0x903}, {0x93e, 0x940},
+    {0x949, 0x94c}, {0x982, 0x983}, {0x9be, 0x9c0}, {0x9c7, 0x9c8},
+    {0x9cb, 0x9cc}, {0x9d7, 0x9d7}, {0xa03, 0xa03}, {0xa3e, 0xa40},
+    {0xa83, 0xa83}, {0xabe, 0xac0}, {0xac9, 0xac9}, {0xacb, 0xacc},
+    {0xb02, 0xb03}, {0xb3e, 0xb3e}, {0xb40, 0xb40}, {0xb47, 0xb48},
+    {0xb4b, 0xb4c}, {0xb57, 0xb57}, {0xbbe, 0xbbf}, {0xbc1, 0xbc2},
+    {0xbc6, 0xbc8}, {0xbca, 0xbcc}, {0xbd7, 0xbd7}, {0xc01, 0xc03},
+    {0xc41, 0xc44}, {0xc82, 0xc83}, {0xcbe, 0xcbe}, {0xcc0, 0xcc4},
+    {0xcc7, 0xcc8}, {0xcca, 0xccb}, {0xcd5, 0xcd6}, {0xd02, 0xd03},
+    {0xd3e, 0xd40}, {0xd46, 0xd48}, {0xd4a, 0xd4c}, {0xd57, 0xd57},
+    {0xd82, 0xd83}, {0xdcf, 0xdd1}, {0xdd8, 0xddf}, {0xdf2, 0xdf3},
+    {0xf3e, 0xf3f}, {0xf7f, 0xf7f}, {0x102c, 0x102c}, {0x1031, 0x1031},
+    {0x1038, 0x1038}, {0x1056, 0x1057}, {0x17b6, 0x17b6}, {0x17be, 0x17c5},
+    {0x17c7, 0x17c8}, {0x1923, 0x1926}, {0x1929, 0x192b}, {0x1930, 0x1931},
+    {0x1933, 0x1938}};
+static const xmlChLRange xmlMcL[] = {{0x1d165, 0x1d166}, {0x1d16d, 0x1d172}};
+static const xmlChRangeGroup xmlMcG = {55,2,xmlMcS,xmlMcL};
+
+static const xmlChSRange xmlMnS[] = {{0x300, 0x357}, {0x35d, 0x36f},
+    {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, {0x5bb, 0x5bd},
+    {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, {0x610, 0x615},
+    {0x64b, 0x658}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6df, 0x6e4},
+    {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x711, 0x711}, {0x730, 0x74a},
+    {0x7a6, 0x7b0}, {0x901, 0x902}, {0x93c, 0x93c}, {0x941, 0x948},
+    {0x94d, 0x94d}, {0x951, 0x954}, {0x962, 0x963}, {0x981, 0x981},
+    {0x9bc, 0x9bc}, {0x9c1, 0x9c4}, {0x9cd, 0x9cd}, {0x9e2, 0x9e3},
+    {0xa01, 0xa02}, {0xa3c, 0xa3c}, {0xa41, 0xa42}, {0xa47, 0xa48},
+    {0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa82}, {0xabc, 0xabc},
+    {0xac1, 0xac5}, {0xac7, 0xac8}, {0xacd, 0xacd}, {0xae2, 0xae3},
+    {0xb01, 0xb01}, {0xb3c, 0xb3c}, {0xb3f, 0xb3f}, {0xb41, 0xb43},
+    {0xb4d, 0xb4d}, {0xb56, 0xb56}, {0xb82, 0xb82}, {0xbc0, 0xbc0},
+    {0xbcd, 0xbcd}, {0xc3e, 0xc40}, {0xc46, 0xc48}, {0xc4a, 0xc4d},
+    {0xc55, 0xc56}, {0xcbc, 0xcbc}, {0xcbf, 0xcbf}, {0xcc6, 0xcc6},
+    {0xccc, 0xccd}, {0xd41, 0xd43}, {0xd4d, 0xd4d}, {0xdca, 0xdca},
+    {0xdd2, 0xdd4}, {0xdd6, 0xdd6}, {0xe31, 0xe31}, {0xe34, 0xe3a},
+    {0xe47, 0xe4e}, {0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc},
+    {0xec8, 0xecd}, {0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37},
+    {0xf39, 0xf39}, {0xf71, 0xf7e}, {0xf80, 0xf84}, {0xf86, 0xf87},
+    {0xf90, 0xf97}, {0xf99, 0xfbc}, {0xfc6, 0xfc6}, {0x102d, 0x1030},
+    {0x1032, 0x1032}, {0x1036, 0x1037}, {0x1039, 0x1039}, {0x1058, 0x1059},
+    {0x1712, 0x1714}, {0x1732, 0x1734}, {0x1752, 0x1753}, {0x1772, 0x1773},
+    {0x17b7, 0x17bd}, {0x17c6, 0x17c6}, {0x17c9, 0x17d3}, {0x17dd, 0x17dd},
+    {0x180b, 0x180d}, {0x18a9, 0x18a9}, {0x1920, 0x1922}, {0x1927, 0x1928},
+    {0x1932, 0x1932}, {0x1939, 0x193b}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1},
+    {0x20e5, 0x20ea}, {0x302a, 0x302f}, {0x3099, 0x309a}, {0xfb1e, 0xfb1e},
+    {0xfe00, 0xfe0f}, {0xfe20, 0xfe23}};
+static const xmlChLRange xmlMnL[] = {{0x1d167, 0x1d169}, {0x1d17b, 0x1d182},
+    {0x1d185, 0x1d18b}, {0x1d1aa, 0x1d1ad}, {0xe0100, 0xe01ef}};
+static const xmlChRangeGroup xmlMnG = {108,5,xmlMnS,xmlMnL};
+
+static const xmlChSRange xmlNS[] = {{0x30, 0x39}, {0xb2, 0xb3},
+    {0xb9, 0xb9}, {0xbc, 0xbe}, {0x660, 0x669}, {0x6f0, 0x6f9},
+    {0x966, 0x96f}, {0x9e6, 0x9ef}, {0x9f4, 0x9f9}, {0xa66, 0xa6f},
+    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbf2}, {0xc66, 0xc6f},
+    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
+    {0xf20, 0xf33}, {0x1040, 0x1049}, {0x1369, 0x137c}, {0x16ee, 0x16f0},
+    {0x17e0, 0x17e9}, {0x17f0, 0x17f9}, {0x1810, 0x1819}, {0x1946, 0x194f},
+    {0x2070, 0x2070}, {0x2074, 0x2079}, {0x2080, 0x2089}, {0x2153, 0x2183},
+    {0x2460, 0x249b}, {0x24ea, 0x24ff}, {0x2776, 0x2793}, {0x3007, 0x3007},
+    {0x3021, 0x3029}, {0x3038, 0x303a}, {0x3192, 0x3195}, {0x3220, 0x3229},
+    {0x3251, 0x325f}, {0x3280, 0x3289}, {0x32b1, 0x32bf}, {0xff10, 0xff19}};
+static const xmlChLRange xmlNL[] = {{0x10107, 0x10133}, {0x10320, 0x10323},
+    {0x1034a, 0x1034a}, {0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff}};
+static const xmlChRangeGroup xmlNG = {42,5,xmlNS,xmlNL};
+
+static const xmlChSRange xmlNdS[] = {{0x30, 0x39}, {0x660, 0x669},
+    {0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f},
+    {0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f},
+    {0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9},
+    {0xf20, 0xf29}, {0x1040, 0x1049}, {0x1369, 0x1371}, {0x17e0, 0x17e9},
+    {0x1810, 0x1819}, {0x1946, 0x194f}, {0xff10, 0xff19}};
+static const xmlChLRange xmlNdL[] = {{0x104a0, 0x104a9}, {0x1d7ce, 0x1d7ff}};
+static const xmlChRangeGroup xmlNdG = {21,2,xmlNdS,xmlNdL};
+
+static const xmlChSRange xmlNoS[] = {{0xb2, 0xb3}, {0xb9, 0xb9},
+    {0xbc, 0xbe}, {0x9f4, 0x9f9}, {0xbf0, 0xbf2}, {0xf2a, 0xf33},
+    {0x1372, 0x137c}, {0x17f0, 0x17f9}, {0x2070, 0x2070}, {0x2074, 0x2079},
+    {0x2080, 0x2089}, {0x2153, 0x215f}, {0x2460, 0x249b}, {0x24ea, 0x24ff},
+    {0x2776, 0x2793}, {0x3192, 0x3195}, {0x3220, 0x3229}, {0x3251, 0x325f},
+    {0x3280, 0x3289}, {0x32b1, 0x32bf}};
+static const xmlChLRange xmlNoL[] = {{0x10107, 0x10133}, {0x10320, 0x10323}};
+static const xmlChRangeGroup xmlNoG = {20,2,xmlNoS,xmlNoL};
+
+static const xmlChSRange xmlPS[] = {{0x21, 0x23}, {0x25, 0x2a},
+    {0x2c, 0x2f}, {0x3a, 0x3b}, {0x3f, 0x40}, {0x5b, 0x5d}, {0x5f, 0x5f},
+    {0x7b, 0x7b}, {0x7d, 0x7d}, {0xa1, 0xa1}, {0xab, 0xab}, {0xb7, 0xb7},
+    {0xbb, 0xbb}, {0xbf, 0xbf}, {0x37e, 0x37e}, {0x387, 0x387},
+    {0x55a, 0x55f}, {0x589, 0x58a}, {0x5be, 0x5be}, {0x5c0, 0x5c0},
+    {0x5c3, 0x5c3}, {0x5f3, 0x5f4}, {0x60c, 0x60d}, {0x61b, 0x61b},
+    {0x61f, 0x61f}, {0x66a, 0x66d}, {0x6d4, 0x6d4}, {0x700, 0x70d},
+    {0x964, 0x965}, {0x970, 0x970}, {0xdf4, 0xdf4}, {0xe4f, 0xe4f},
+    {0xe5a, 0xe5b}, {0xf04, 0xf12}, {0xf3a, 0xf3d}, {0xf85, 0xf85},
+    {0x104a, 0x104f}, {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e},
+    {0x169b, 0x169c}, {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6},
+    {0x17d8, 0x17da}, {0x1800, 0x180a}, {0x1944, 0x1945}, {0x2010, 0x2027},
+    {0x2030, 0x2043}, {0x2045, 0x2051}, {0x2053, 0x2054}, {0x2057, 0x2057},
+    {0x207d, 0x207e}, {0x208d, 0x208e}, {0x2329, 0x232a}, {0x23b4, 0x23b6},
+    {0x2768, 0x2775}, {0x27e6, 0x27eb}, {0x2983, 0x2998}, {0x29d8, 0x29db},
+    {0x29fc, 0x29fd}, {0x3001, 0x3003}, {0x3008, 0x3011}, {0x3014, 0x301f},
+    {0x3030, 0x3030}, {0x303d, 0x303d}, {0x30a0, 0x30a0}, {0x30fb, 0x30fb},
+    {0xfd3e, 0xfd3f}, {0xfe30, 0xfe52}, {0xfe54, 0xfe61}, {0xfe63, 0xfe63},
+    {0xfe68, 0xfe68}, {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff0a},
+    {0xff0c, 0xff0f}, {0xff1a, 0xff1b}, {0xff1f, 0xff20}, {0xff3b, 0xff3d},
+    {0xff3f, 0xff3f}, {0xff5b, 0xff5b}, {0xff5d, 0xff5d}, {0xff5f, 0xff65}};
+static const xmlChLRange xmlPL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f}};
+static const xmlChRangeGroup xmlPG = {84,2,xmlPS,xmlPL};
+
+static const xmlChSRange xmlPdS[] = {{0x2d, 0x2d}, {0x58a, 0x58a},
+    {0x1806, 0x1806}, {0x2010, 0x2015}, {0x301c, 0x301c}, {0x3030, 0x3030},
+    {0x30a0, 0x30a0}, {0xfe31, 0xfe32}, {0xfe58, 0xfe58}, {0xfe63, 0xfe63},
+    {0xff0d, 0xff0d}};
+static const xmlChRangeGroup xmlPdG = {11,0,xmlPdS,NULL};
+
+static const xmlChSRange xmlPeS[] = {{0x29, 0x29}, {0x5d, 0x5d},
+    {0x7d, 0x7d}, {0xf3b, 0xf3b}, {0xf3d, 0xf3d}, {0x169c, 0x169c},
+    {0x2046, 0x2046}, {0x207e, 0x207e}, {0x208e, 0x208e}, {0x232a, 0x232a},
+    {0x23b5, 0x23b5}, {0x2769, 0x2769}, {0x276b, 0x276b}, {0x276d, 0x276d},
+    {0x276f, 0x276f}, {0x2771, 0x2771}, {0x2773, 0x2773}, {0x2775, 0x2775},
+    {0x27e7, 0x27e7}, {0x27e9, 0x27e9}, {0x27eb, 0x27eb}, {0x2984, 0x2984},
+    {0x2986, 0x2986}, {0x2988, 0x2988}, {0x298a, 0x298a}, {0x298c, 0x298c},
+    {0x298e, 0x298e}, {0x2990, 0x2990}, {0x2992, 0x2992}, {0x2994, 0x2994},
+    {0x2996, 0x2996}, {0x2998, 0x2998}, {0x29d9, 0x29d9}, {0x29db, 0x29db},
+    {0x29fd, 0x29fd}, {0x3009, 0x3009}, {0x300b, 0x300b}, {0x300d, 0x300d},
+    {0x300f, 0x300f}, {0x3011, 0x3011}, {0x3015, 0x3015}, {0x3017, 0x3017},
+    {0x3019, 0x3019}, {0x301b, 0x301b}, {0x301e, 0x301f}, {0xfd3f, 0xfd3f},
+    {0xfe36, 0xfe36}, {0xfe38, 0xfe38}, {0xfe3a, 0xfe3a}, {0xfe3c, 0xfe3c},
+    {0xfe3e, 0xfe3e}, {0xfe40, 0xfe40}, {0xfe42, 0xfe42}, {0xfe44, 0xfe44},
+    {0xfe48, 0xfe48}, {0xfe5a, 0xfe5a}, {0xfe5c, 0xfe5c}, {0xfe5e, 0xfe5e},
+    {0xff09, 0xff09}, {0xff3d, 0xff3d}, {0xff5d, 0xff5d}, {0xff60, 0xff60},
+    {0xff63, 0xff63}};
+static const xmlChRangeGroup xmlPeG = {63,0,xmlPeS,NULL};
+
+static const xmlChSRange xmlPoS[] = {{0x21, 0x23}, {0x25, 0x27},
+    {0x2a, 0x2a}, {0x2c, 0x2c}, {0x2e, 0x2f}, {0x3a, 0x3b}, {0x3f, 0x40},
+    {0x5c, 0x5c}, {0xa1, 0xa1}, {0xb7, 0xb7}, {0xbf, 0xbf}, {0x37e, 0x37e},
+    {0x387, 0x387}, {0x55a, 0x55f}, {0x589, 0x589}, {0x5be, 0x5be},
+    {0x5c0, 0x5c0}, {0x5c3, 0x5c3}, {0x5f3, 0x5f4}, {0x60c, 0x60d},
+    {0x61b, 0x61b}, {0x61f, 0x61f}, {0x66a, 0x66d}, {0x6d4, 0x6d4},
+    {0x700, 0x70d}, {0x964, 0x965}, {0x970, 0x970}, {0xdf4, 0xdf4},
+    {0xe4f, 0xe4f}, {0xe5a, 0xe5b}, {0xf04, 0xf12}, {0xf85, 0xf85},
+    {0x104a, 0x104f}, {0x10fb, 0x10fb}, {0x1361, 0x1368}, {0x166d, 0x166e},
+    {0x16eb, 0x16ed}, {0x1735, 0x1736}, {0x17d4, 0x17d6}, {0x17d8, 0x17da},
+    {0x1800, 0x1805}, {0x1807, 0x180a}, {0x1944, 0x1945}, {0x2016, 0x2017},
+    {0x2020, 0x2027}, {0x2030, 0x2038}, {0x203b, 0x203e}, {0x2041, 0x2043},
+    {0x2047, 0x2051}, {0x2053, 0x2053}, {0x2057, 0x2057}, {0x23b6, 0x23b6},
+    {0x3001, 0x3003}, {0x303d, 0x303d}, {0xfe30, 0xfe30}, {0xfe45, 0xfe46},
+    {0xfe49, 0xfe4c}, {0xfe50, 0xfe52}, {0xfe54, 0xfe57}, {0xfe5f, 0xfe61},
+    {0xfe68, 0xfe68}, {0xfe6a, 0xfe6b}, {0xff01, 0xff03}, {0xff05, 0xff07},
+    {0xff0a, 0xff0a}, {0xff0c, 0xff0c}, {0xff0e, 0xff0f}, {0xff1a, 0xff1b},
+    {0xff1f, 0xff20}, {0xff3c, 0xff3c}, {0xff61, 0xff61}, {0xff64, 0xff64}};
+static const xmlChLRange xmlPoL[] = {{0x10100, 0x10101}, {0x1039f, 0x1039f}};
+static const xmlChRangeGroup xmlPoG = {72,2,xmlPoS,xmlPoL};
+
+static const xmlChSRange xmlPsS[] = {{0x28, 0x28}, {0x5b, 0x5b},
+    {0x7b, 0x7b}, {0xf3a, 0xf3a}, {0xf3c, 0xf3c}, {0x169b, 0x169b},
+    {0x201a, 0x201a}, {0x201e, 0x201e}, {0x2045, 0x2045}, {0x207d, 0x207d},
+    {0x208d, 0x208d}, {0x2329, 0x2329}, {0x23b4, 0x23b4}, {0x2768, 0x2768},
+    {0x276a, 0x276a}, {0x276c, 0x276c}, {0x276e, 0x276e}, {0x2770, 0x2770},
+    {0x2772, 0x2772}, {0x2774, 0x2774}, {0x27e6, 0x27e6}, {0x27e8, 0x27e8},
+    {0x27ea, 0x27ea}, {0x2983, 0x2983}, {0x2985, 0x2985}, {0x2987, 0x2987},
+    {0x2989, 0x2989}, {0x298b, 0x298b}, {0x298d, 0x298d}, {0x298f, 0x298f},
+    {0x2991, 0x2991}, {0x2993, 0x2993}, {0x2995, 0x2995}, {0x2997, 0x2997},
+    {0x29d8, 0x29d8}, {0x29da, 0x29da}, {0x29fc, 0x29fc}, {0x3008, 0x3008},
+    {0x300a, 0x300a}, {0x300c, 0x300c}, {0x300e, 0x300e}, {0x3010, 0x3010},
+    {0x3014, 0x3014}, {0x3016, 0x3016}, {0x3018, 0x3018}, {0x301a, 0x301a},
+    {0x301d, 0x301d}, {0xfd3e, 0xfd3e}, {0xfe35, 0xfe35}, {0xfe37, 0xfe37},
+    {0xfe39, 0xfe39}, {0xfe3b, 0xfe3b}, {0xfe3d, 0xfe3d}, {0xfe3f, 0xfe3f},
+    {0xfe41, 0xfe41}, {0xfe43, 0xfe43}, {0xfe47, 0xfe47}, {0xfe59, 0xfe59},
+    {0xfe5b, 0xfe5b}, {0xfe5d, 0xfe5d}, {0xff08, 0xff08}, {0xff3b, 0xff3b},
+    {0xff5b, 0xff5b}, {0xff5f, 0xff5f}, {0xff62, 0xff62}};
+static const xmlChRangeGroup xmlPsG = {65,0,xmlPsS,NULL};
+
+static const xmlChSRange xmlSS[] = {{0x24, 0x24}, {0x2b, 0x2b},
+    {0x3c, 0x3e}, {0x5e, 0x5e}, {0x60, 0x60}, {0x7c, 0x7c}, {0x7e, 0x7e},
+    {0xa2, 0xa9}, {0xac, 0xac}, {0xae, 0xb1}, {0xb4, 0xb4}, {0xb6, 0xb6},
+    {0xb8, 0xb8}, {0xd7, 0xd7}, {0xf7, 0xf7}, {0x2c2, 0x2c5},
+    {0x2d2, 0x2df}, {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375},
+    {0x384, 0x385}, {0x3f6, 0x3f6}, {0x482, 0x482}, {0x60e, 0x60f},
+    {0x6e9, 0x6e9}, {0x6fd, 0x6fe}, {0x9f2, 0x9f3}, {0x9fa, 0x9fa},
+    {0xaf1, 0xaf1}, {0xb70, 0xb70}, {0xbf3, 0xbfa}, {0xe3f, 0xe3f},
+    {0xf01, 0xf03}, {0xf13, 0xf17}, {0xf1a, 0xf1f}, {0xf34, 0xf34},
+    {0xf36, 0xf36}, {0xf38, 0xf38}, {0xfbe, 0xfc5}, {0xfc7, 0xfcc},
+    {0xfcf, 0xfcf}, {0x17db, 0x17db}, {0x1940, 0x1940}, {0x19e0, 0x19ff},
+    {0x1fbd, 0x1fbd}, {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf}, {0x1fdd, 0x1fdf},
+    {0x1fed, 0x1fef}, {0x1ffd, 0x1ffe}, {0x2044, 0x2044}, {0x2052, 0x2052},
+    {0x207a, 0x207c}, {0x208a, 0x208c}, {0x20a0, 0x20b1}, {0x2100, 0x2101},
+    {0x2103, 0x2106}, {0x2108, 0x2109}, {0x2114, 0x2114}, {0x2116, 0x2118},
+    {0x211e, 0x2123}, {0x2125, 0x2125}, {0x2127, 0x2127}, {0x2129, 0x2129},
+    {0x212e, 0x212e}, {0x2132, 0x2132}, {0x213a, 0x213b}, {0x2140, 0x2144},
+    {0x214a, 0x214b}, {0x2190, 0x2328}, {0x232b, 0x23b3}, {0x23b7, 0x23d0},
+    {0x2400, 0x2426}, {0x2440, 0x244a}, {0x249c, 0x24e9}, {0x2500, 0x2617},
+    {0x2619, 0x267d}, {0x2680, 0x2691}, {0x26a0, 0x26a1}, {0x2701, 0x2704},
+    {0x2706, 0x2709}, {0x270c, 0x2727}, {0x2729, 0x274b}, {0x274d, 0x274d},
+    {0x274f, 0x2752}, {0x2756, 0x2756}, {0x2758, 0x275e}, {0x2761, 0x2767},
+    {0x2794, 0x2794}, {0x2798, 0x27af}, {0x27b1, 0x27be}, {0x27d0, 0x27e5},
+    {0x27f0, 0x2982}, {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2b0d},
+    {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb},
+    {0x3004, 0x3004}, {0x3012, 0x3013}, {0x3020, 0x3020}, {0x3036, 0x3037},
+    {0x303e, 0x303f}, {0x309b, 0x309c}, {0x3190, 0x3191}, {0x3196, 0x319f},
+    {0x3200, 0x321e}, {0x322a, 0x3243}, {0x3250, 0x3250}, {0x3260, 0x327d},
+    {0x327f, 0x327f}, {0x328a, 0x32b0}, {0x32c0, 0x32fe}, {0x3300, 0x33ff},
+    {0x4dc0, 0x4dff}, {0xa490, 0xa4c6}, {0xfb29, 0xfb29}, {0xfdfc, 0xfdfd},
+    {0xfe62, 0xfe62}, {0xfe64, 0xfe66}, {0xfe69, 0xfe69}, {0xff04, 0xff04},
+    {0xff0b, 0xff0b}, {0xff1c, 0xff1e}, {0xff3e, 0xff3e}, {0xff40, 0xff40},
+    {0xff5c, 0xff5c}, {0xff5e, 0xff5e}, {0xffe0, 0xffe6}, {0xffe8, 0xffee},
+    {0xfffc, 0xfffd}};
+static const xmlChLRange xmlSL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f},
+    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164},
+    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9},
+    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356}, {0x1d6c1, 0x1d6c1},
+    {0x1d6db, 0x1d6db}, {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715},
+    {0x1d735, 0x1d735}, {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f},
+    {0x1d789, 0x1d789}, {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3}};
+static const xmlChRangeGroup xmlSG = {133,20,xmlSS,xmlSL};
+
+static const xmlChSRange xmlScS[] = {{0x24, 0x24}, {0xa2, 0xa5},
+    {0x9f2, 0x9f3}, {0xaf1, 0xaf1}, {0xbf9, 0xbf9}, {0xe3f, 0xe3f},
+    {0x17db, 0x17db}, {0x20a0, 0x20b1}, {0xfdfc, 0xfdfc}, {0xfe69, 0xfe69},
+    {0xff04, 0xff04}, {0xffe0, 0xffe1}, {0xffe5, 0xffe6}};
+static const xmlChRangeGroup xmlScG = {13,0,xmlScS,NULL};
+
+static const xmlChSRange xmlSkS[] = {{0x5e, 0x5e}, {0x60, 0x60},
+    {0xa8, 0xa8}, {0xaf, 0xaf}, {0xb4, 0xb4}, {0xb8, 0xb8}, {0x2c2, 0x2c5},
+    {0x2d2, 0x2df}, {0x2e5, 0x2ed}, {0x2ef, 0x2ff}, {0x374, 0x375},
+    {0x384, 0x385}, {0x1fbd, 0x1fbd}, {0x1fbf, 0x1fc1}, {0x1fcd, 0x1fcf},
+    {0x1fdd, 0x1fdf}, {0x1fed, 0x1fef}, {0x1ffd, 0x1ffe}, {0x309b, 0x309c},
+    {0xff3e, 0xff3e}, {0xff40, 0xff40}, {0xffe3, 0xffe3}};
+static const xmlChRangeGroup xmlSkG = {22,0,xmlSkS,NULL};
+
+static const xmlChSRange xmlSmS[] = {{0x2b, 0x2b}, {0x3c, 0x3e},
+    {0x7c, 0x7c}, {0x7e, 0x7e}, {0xac, 0xac}, {0xb1, 0xb1}, {0xd7, 0xd7},
+    {0xf7, 0xf7}, {0x3f6, 0x3f6}, {0x2044, 0x2044}, {0x2052, 0x2052},
+    {0x207a, 0x207c}, {0x208a, 0x208c}, {0x2140, 0x2144}, {0x214b, 0x214b},
+    {0x2190, 0x2194}, {0x219a, 0x219b}, {0x21a0, 0x21a0}, {0x21a3, 0x21a3},
+    {0x21a6, 0x21a6}, {0x21ae, 0x21ae}, {0x21ce, 0x21cf}, {0x21d2, 0x21d2},
+    {0x21d4, 0x21d4}, {0x21f4, 0x22ff}, {0x2308, 0x230b}, {0x2320, 0x2321},
+    {0x237c, 0x237c}, {0x239b, 0x23b3}, {0x25b7, 0x25b7}, {0x25c1, 0x25c1},
+    {0x25f8, 0x25ff}, {0x266f, 0x266f}, {0x27d0, 0x27e5}, {0x27f0, 0x27ff},
+    {0x2900, 0x2982}, {0x2999, 0x29d7}, {0x29dc, 0x29fb}, {0x29fe, 0x2aff},
+    {0xfb29, 0xfb29}, {0xfe62, 0xfe62}, {0xfe64, 0xfe66}, {0xff0b, 0xff0b},
+    {0xff1c, 0xff1e}, {0xff5c, 0xff5c}, {0xff5e, 0xff5e}, {0xffe2, 0xffe2},
+    {0xffe9, 0xffec}};
+static const xmlChLRange xmlSmL[] = {{0x1d6c1, 0x1d6c1}, {0x1d6db, 0x1d6db},
+    {0x1d6fb, 0x1d6fb}, {0x1d715, 0x1d715}, {0x1d735, 0x1d735},
+    {0x1d74f, 0x1d74f}, {0x1d76f, 0x1d76f}, {0x1d789, 0x1d789},
+    {0x1d7a9, 0x1d7a9}, {0x1d7c3, 0x1d7c3}};
+static const xmlChRangeGroup xmlSmG = {48,10,xmlSmS,xmlSmL};
+
+static const xmlChSRange xmlSoS[] = {{0xa6, 0xa7}, {0xa9, 0xa9},
+    {0xae, 0xae}, {0xb0, 0xb0}, {0xb6, 0xb6}, {0x482, 0x482},
+    {0x60e, 0x60f}, {0x6e9, 0x6e9}, {0x6fd, 0x6fe}, {0x9fa, 0x9fa},
+    {0xb70, 0xb70}, {0xbf3, 0xbf8}, {0xbfa, 0xbfa}, {0xf01, 0xf03},
+    {0xf13, 0xf17}, {0xf1a, 0xf1f}, {0xf34, 0xf34}, {0xf36, 0xf36},
+    {0xf38, 0xf38}, {0xfbe, 0xfc5}, {0xfc7, 0xfcc}, {0xfcf, 0xfcf},
+    {0x1940, 0x1940}, {0x19e0, 0x19ff}, {0x2100, 0x2101}, {0x2103, 0x2106},
+    {0x2108, 0x2109}, {0x2114, 0x2114}, {0x2116, 0x2118}, {0x211e, 0x2123},
+    {0x2125, 0x2125}, {0x2127, 0x2127}, {0x2129, 0x2129}, {0x212e, 0x212e},
+    {0x2132, 0x2132}, {0x213a, 0x213b}, {0x214a, 0x214a}, {0x2195, 0x2199},
+    {0x219c, 0x219f}, {0x21a1, 0x21a2}, {0x21a4, 0x21a5}, {0x21a7, 0x21ad},
+    {0x21af, 0x21cd}, {0x21d0, 0x21d1}, {0x21d3, 0x21d3}, {0x21d5, 0x21f3},
+    {0x2300, 0x2307}, {0x230c, 0x231f}, {0x2322, 0x2328}, {0x232b, 0x237b},
+    {0x237d, 0x239a}, {0x23b7, 0x23d0}, {0x2400, 0x2426}, {0x2440, 0x244a},
+    {0x249c, 0x24e9}, {0x2500, 0x25b6}, {0x25b8, 0x25c0}, {0x25c2, 0x25f7},
+    {0x2600, 0x2617}, {0x2619, 0x266e}, {0x2670, 0x267d}, {0x2680, 0x2691},
+    {0x26a0, 0x26a1}, {0x2701, 0x2704}, {0x2706, 0x2709}, {0x270c, 0x2727},
+    {0x2729, 0x274b}, {0x274d, 0x274d}, {0x274f, 0x2752}, {0x2756, 0x2756},
+    {0x2758, 0x275e}, {0x2761, 0x2767}, {0x2794, 0x2794}, {0x2798, 0x27af},
+    {0x27b1, 0x27be}, {0x2800, 0x28ff}, {0x2b00, 0x2b0d}, {0x2e80, 0x2e99},
+    {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2ffb}, {0x3004, 0x3004},
+    {0x3012, 0x3013}, {0x3020, 0x3020}, {0x3036, 0x3037}, {0x303e, 0x303f},
+    {0x3190, 0x3191}, {0x3196, 0x319f}, {0x3200, 0x321e}, {0x322a, 0x3243},
+    {0x3250, 0x3250}, {0x3260, 0x327d}, {0x327f, 0x327f}, {0x328a, 0x32b0},
+    {0x32c0, 0x32fe}, {0x3300, 0x33ff}, {0x4dc0, 0x4dff}, {0xa490, 0xa4c6},
+    {0xfdfd, 0xfdfd}, {0xffe4, 0xffe4}, {0xffe8, 0xffe8}, {0xffed, 0xffee},
+    {0xfffc, 0xfffd}};
+static const xmlChLRange xmlSoL[] = {{0x10102, 0x10102}, {0x10137, 0x1013f},
+    {0x1d000, 0x1d0f5}, {0x1d100, 0x1d126}, {0x1d12a, 0x1d164},
+    {0x1d16a, 0x1d16c}, {0x1d183, 0x1d184}, {0x1d18c, 0x1d1a9},
+    {0x1d1ae, 0x1d1dd}, {0x1d300, 0x1d356}};
+static const xmlChRangeGroup xmlSoG = {103,10,xmlSoS,xmlSoL};
+
+static const xmlChSRange xmlZS[] = {{0x20, 0x20}, {0xa0, 0xa0},
+    {0x1680, 0x1680}, {0x180e, 0x180e}, {0x2000, 0x200a}, {0x2028, 0x2029},
+    {0x202f, 0x202f}, {0x205f, 0x205f}, {0x3000, 0x3000}};
+static const xmlChRangeGroup xmlZG = {9,0,xmlZS,NULL};
+
+static int
+xmlUCSIsCatC(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlCG));
+}
+
+static int
+xmlUCSIsCatCc(int code) {
+    return(((code >= 0x0) && (code <= 0x1f)) ||
+           ((code >= 0x7f) && (code <= 0x9f)));
+}
+
+static int
+xmlUCSIsCatCf(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlCfG));
+}
+
+static int
+xmlUCSIsCatCo(int code) {
+    return((code == 0xe000) ||
+           (code == 0xf8ff) ||
+           (code == 0xf0000) ||
+           (code == 0xffffd) ||
+           (code == 0x100000) ||
+           (code == 0x10fffd));
+}
+
+static int
+xmlUCSIsCatL(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLG));
+}
+
+static int
+xmlUCSIsCatLl(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLlG));
+}
+
+static int
+xmlUCSIsCatLm(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLmG));
+}
+
+static int
+xmlUCSIsCatLo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLoG));
+}
+
+static int
+xmlUCSIsCatLt(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLtG));
+}
+
+static int
+xmlUCSIsCatLu(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlLuG));
+}
+
+static int
+xmlUCSIsCatM(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMG));
+}
+
+static int
+xmlUCSIsCatMc(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMcG));
+}
+
+static int
+xmlUCSIsCatMe(int code) {
+    return(((code >= 0x488) && (code <= 0x489)) ||
+           (code == 0x6de) ||
+           ((code >= 0x20dd) && (code <= 0x20e0)) ||
+           ((code >= 0x20e2) && (code <= 0x20e4)));
+}
+
+static int
+xmlUCSIsCatMn(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlMnG));
+}
+
+static int
+xmlUCSIsCatN(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNG));
+}
+
+static int
+xmlUCSIsCatNd(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNdG));
+}
+
+static int
+xmlUCSIsCatNl(int code) {
+    return(((code >= 0x16ee) && (code <= 0x16f0)) ||
+           ((code >= 0x2160) && (code <= 0x2183)) ||
+           (code == 0x3007) ||
+           ((code >= 0x3021) && (code <= 0x3029)) ||
+           ((code >= 0x3038) && (code <= 0x303a)) ||
+           (code == 0x1034a));
+}
+
+static int
+xmlUCSIsCatNo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlNoG));
+}
+
+static int
+xmlUCSIsCatP(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPG));
+}
+
+static int
+xmlUCSIsCatPc(int code) {
+    return((code == 0x5f) ||
+           ((code >= 0x203f) && (code <= 0x2040)) ||
+           (code == 0x2054) ||
+           (code == 0x30fb) ||
+           ((code >= 0xfe33) && (code <= 0xfe34)) ||
+           ((code >= 0xfe4d) && (code <= 0xfe4f)) ||
+           (code == 0xff3f) ||
+           (code == 0xff65));
+}
+
+static int
+xmlUCSIsCatPd(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPdG));
+}
+
+static int
+xmlUCSIsCatPe(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPeG));
+}
+
+static int
+xmlUCSIsCatPf(int code) {
+    return((code == 0xbb) ||
+           (code == 0x2019) ||
+           (code == 0x201d) ||
+           (code == 0x203a));
+}
+
+static int
+xmlUCSIsCatPi(int code) {
+    return((code == 0xab) ||
+           (code == 0x2018) ||
+           ((code >= 0x201b) && (code <= 0x201c)) ||
+           (code == 0x201f) ||
+           (code == 0x2039));
+}
+
+static int
+xmlUCSIsCatPo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPoG));
+}
+
+static int
+xmlUCSIsCatPs(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlPsG));
+}
+
+static int
+xmlUCSIsCatS(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSG));
+}
+
+static int
+xmlUCSIsCatSc(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlScG));
+}
+
+static int
+xmlUCSIsCatSk(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSkG));
+}
+
+static int
+xmlUCSIsCatSm(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSmG));
+}
+
+static int
+xmlUCSIsCatSo(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlSoG));
+}
+
+static int
+xmlUCSIsCatZ(int code) {
+    return(xmlCharInRange((unsigned int)code, &xmlZG));
+}
+
+static int
+xmlUCSIsCatZl(int code) {
+    return((code == 0x2028));
+}
+
+static int
+xmlUCSIsCatZp(int code) {
+    return((code == 0x2029));
+}
+
+static int
+xmlUCSIsCatZs(int code) {
+    return((code == 0x20) ||
+           (code == 0xa0) ||
+           (code == 0x1680) ||
+           (code == 0x180e) ||
+           ((code >= 0x2000) && (code <= 0x200a)) ||
+           (code == 0x202f) ||
+           (code == 0x205f) ||
+           (code == 0x3000));
+}
+
+static const xmlChLRange xmlAegeanNumbersL[] = {{0x10100, 0x1013f}};
+
+static const xmlChSRange xmlAlphabeticPresentationFormsS[] = {
+    {0xfb00, 0xfb4f}};
+
+static const xmlChSRange xmlArabicS[] = {{0x600, 0x6ff}};
+
+static const xmlChSRange xmlArabicPresentationFormsAS[] = {{0xfb50, 0xfdff}};
+
+static const xmlChSRange xmlArabicPresentationFormsBS[] = {{0xfe70, 0xfeff}};
+
+static const xmlChSRange xmlArmenianS[] = {{0x530, 0x58f}};
+
+static const xmlChSRange xmlArrowsS[] = {{0x2190, 0x21ff}};
+
+static const xmlChSRange xmlBasicLatinS[] = {{0x0, 0x7f}};
+
+static const xmlChSRange xmlBengaliS[] = {{0x980, 0x9ff}};
+
+static const xmlChSRange xmlBlockElementsS[] = {{0x2580, 0x259f}};
+
+static const xmlChSRange xmlBopomofoS[] = {{0x3100, 0x312f}};
+
+static const xmlChSRange xmlBopomofoExtendedS[] = {{0x31a0, 0x31bf}};
+
+static const xmlChSRange xmlBoxDrawingS[] = {{0x2500, 0x257f}};
+
+static const xmlChSRange xmlBraillePatternsS[] = {{0x2800, 0x28ff}};
+
+static const xmlChSRange xmlBuhidS[] = {{0x1740, 0x175f}};
+
+static const xmlChLRange xmlByzantineMusicalSymbolsL[] = {{0x1d000, 0x1d0ff}};
+
+static const xmlChSRange xmlCJKCompatibilityS[] = {{0x3300, 0x33ff}};
+
+static const xmlChSRange xmlCJKCompatibilityFormsS[] = {{0xfe30, 0xfe4f}};
+
+static const xmlChSRange xmlCJKCompatibilityIdeographsS[] = {
+    {0xf900, 0xfaff}};
+
+static const xmlChLRange xmlCJKCompatibilityIdeographsSupplementL[] = {
+    {0x2f800, 0x2fa1f}};
+
+static const xmlChSRange xmlCJKRadicalsSupplementS[] = {{0x2e80, 0x2eff}};
+
+static const xmlChSRange xmlCJKSymbolsandPunctuationS[] = {{0x3000, 0x303f}};
+
+static const xmlChSRange xmlCJKUnifiedIdeographsS[] = {{0x4e00, 0x9fff}};
+
+static const xmlChSRange xmlCJKUnifiedIdeographsExtensionAS[] = {
+    {0x3400, 0x4dbf}};
+
+static const xmlChLRange xmlCJKUnifiedIdeographsExtensionBL[] = {
+    {0x20000, 0x2a6df}};
+
+static const xmlChSRange xmlCherokeeS[] = {{0x13a0, 0x13ff}};
+
+static const xmlChSRange xmlCombiningDiacriticalMarksS[] = {{0x300, 0x36f}};
+
+static const xmlChSRange xmlCombiningDiacriticalMarksforSymbolsS[] = {
+    {0x20d0, 0x20ff}};
+
+static const xmlChSRange xmlCombiningHalfMarksS[] = {{0xfe20, 0xfe2f}};
+
+static const xmlChSRange xmlCombiningMarksforSymbolsS[] = {{0x20d0, 0x20ff}};
+
+static const xmlChSRange xmlControlPicturesS[] = {{0x2400, 0x243f}};
+
+static const xmlChSRange xmlCurrencySymbolsS[] = {{0x20a0, 0x20cf}};
+
+static const xmlChLRange xmlCypriotSyllabaryL[] = {{0x10800, 0x1083f}};
+
+static const xmlChSRange xmlCyrillicS[] = {{0x400, 0x4ff}};
+
+static const xmlChSRange xmlCyrillicSupplementS[] = {{0x500, 0x52f}};
+
+static const xmlChLRange xmlDeseretL[] = {{0x10400, 0x1044f}};
+
+static const xmlChSRange xmlDevanagariS[] = {{0x900, 0x97f}};
+
+static const xmlChSRange xmlDingbatsS[] = {{0x2700, 0x27bf}};
+
+static const xmlChSRange xmlEnclosedAlphanumericsS[] = {{0x2460, 0x24ff}};
+
+static const xmlChSRange xmlEnclosedCJKLettersandMonthsS[] = {
+    {0x3200, 0x32ff}};
+
+static const xmlChSRange xmlEthiopicS[] = {{0x1200, 0x137f}};
+
+static const xmlChSRange xmlGeneralPunctuationS[] = {{0x2000, 0x206f}};
+
+static const xmlChSRange xmlGeometricShapesS[] = {{0x25a0, 0x25ff}};
+
+static const xmlChSRange xmlGeorgianS[] = {{0x10a0, 0x10ff}};
+
+static const xmlChLRange xmlGothicL[] = {{0x10330, 0x1034f}};
+
+static const xmlChSRange xmlGreekS[] = {{0x370, 0x3ff}};
+
+static const xmlChSRange xmlGreekExtendedS[] = {{0x1f00, 0x1fff}};
+
+static const xmlChSRange xmlGreekandCopticS[] = {{0x370, 0x3ff}};
+
+static const xmlChSRange xmlGujaratiS[] = {{0xa80, 0xaff}};
+
+static const xmlChSRange xmlGurmukhiS[] = {{0xa00, 0xa7f}};
+
+static const xmlChSRange xmlHalfwidthandFullwidthFormsS[] = {
+    {0xff00, 0xffef}};
+
+static const xmlChSRange xmlHangulCompatibilityJamoS[] = {{0x3130, 0x318f}};
+
+static const xmlChSRange xmlHangulJamoS[] = {{0x1100, 0x11ff}};
+
+static const xmlChSRange xmlHangulSyllablesS[] = {{0xac00, 0xd7af}};
+
+static const xmlChSRange xmlHanunooS[] = {{0x1720, 0x173f}};
+
+static const xmlChSRange xmlHebrewS[] = {{0x590, 0x5ff}};
+
+static const xmlChSRange xmlHighPrivateUseSurrogatesS[] = {{0xdb80, 0xdbff}};
+
+static const xmlChSRange xmlHighSurrogatesS[] = {{0xd800, 0xdb7f}};
+
+static const xmlChSRange xmlHiraganaS[] = {{0x3040, 0x309f}};
+
+static const xmlChSRange xmlIPAExtensionsS[] = {{0x250, 0x2af}};
+
+static const xmlChSRange xmlIdeographicDescriptionCharactersS[] = {
+    {0x2ff0, 0x2fff}};
+
+static const xmlChSRange xmlKanbunS[] = {{0x3190, 0x319f}};
+
+static const xmlChSRange xmlKangxiRadicalsS[] = {{0x2f00, 0x2fdf}};
+
+static const xmlChSRange xmlKannadaS[] = {{0xc80, 0xcff}};
+
+static const xmlChSRange xmlKatakanaS[] = {{0x30a0, 0x30ff}};
+
+static const xmlChSRange xmlKatakanaPhoneticExtensionsS[] = {
+    {0x31f0, 0x31ff}};
+
+static const xmlChSRange xmlKhmerS[] = {{0x1780, 0x17ff}};
+
+static const xmlChSRange xmlKhmerSymbolsS[] = {{0x19e0, 0x19ff}};
+
+static const xmlChSRange xmlLaoS[] = {{0xe80, 0xeff}};
+
+static const xmlChSRange xmlLatin1SupplementS[] = {{0x80, 0xff}};
+
+static const xmlChSRange xmlLatinExtendedAS[] = {{0x100, 0x17f}};
+
+static const xmlChSRange xmlLatinExtendedBS[] = {{0x180, 0x24f}};
+
+static const xmlChSRange xmlLatinExtendedAdditionalS[] = {{0x1e00, 0x1eff}};
+
+static const xmlChSRange xmlLetterlikeSymbolsS[] = {{0x2100, 0x214f}};
+
+static const xmlChSRange xmlLimbuS[] = {{0x1900, 0x194f}};
+
+static const xmlChLRange xmlLinearBIdeogramsL[] = {{0x10080, 0x100ff}};
+
+static const xmlChLRange xmlLinearBSyllabaryL[] = {{0x10000, 0x1007f}};
+
+static const xmlChSRange xmlLowSurrogatesS[] = {{0xdc00, 0xdfff}};
+
+static const xmlChSRange xmlMalayalamS[] = {{0xd00, 0xd7f}};
+
+static const xmlChLRange xmlMathematicalAlphanumericSymbolsL[] = {
+    {0x1d400, 0x1d7ff}};
+
+static const xmlChSRange xmlMathematicalOperatorsS[] = {{0x2200, 0x22ff}};
+
+static const xmlChSRange xmlMiscellaneousMathematicalSymbolsAS[] = {
+    {0x27c0, 0x27ef}};
+
+static const xmlChSRange xmlMiscellaneousMathematicalSymbolsBS[] = {
+    {0x2980, 0x29ff}};
+
+static const xmlChSRange xmlMiscellaneousSymbolsS[] = {{0x2600, 0x26ff}};
+
+static const xmlChSRange xmlMiscellaneousSymbolsandArrowsS[] = {
+    {0x2b00, 0x2bff}};
+
+static const xmlChSRange xmlMiscellaneousTechnicalS[] = {{0x2300, 0x23ff}};
+
+static const xmlChSRange xmlMongolianS[] = {{0x1800, 0x18af}};
+
+static const xmlChLRange xmlMusicalSymbolsL[] = {{0x1d100, 0x1d1ff}};
+
+static const xmlChSRange xmlMyanmarS[] = {{0x1000, 0x109f}};
+
+static const xmlChSRange xmlNumberFormsS[] = {{0x2150, 0x218f}};
+
+static const xmlChSRange xmlOghamS[] = {{0x1680, 0x169f}};
+
+static const xmlChLRange xmlOldItalicL[] = {{0x10300, 0x1032f}};
+
+static const xmlChSRange xmlOpticalCharacterRecognitionS[] = {
+    {0x2440, 0x245f}};
+
+static const xmlChSRange xmlOriyaS[] = {{0xb00, 0xb7f}};
+
+static const xmlChLRange xmlOsmanyaL[] = {{0x10480, 0x104af}};
+
+static const xmlChSRange xmlPhoneticExtensionsS[] = {{0x1d00, 0x1d7f}};
+
+static const xmlChSRange xmlPrivateUseS[] = {{0xe000, 0xf8ff}};
+static const xmlChLRange xmlPrivateUseL[] = {{0xf0000, 0xfffff},
+    {0x100000, 0x10ffff}};
+
+static const xmlChSRange xmlPrivateUseAreaS[] = {{0xe000, 0xf8ff}};
+
+static const xmlChSRange xmlRunicS[] = {{0x16a0, 0x16ff}};
+
+static const xmlChLRange xmlShavianL[] = {{0x10450, 0x1047f}};
+
+static const xmlChSRange xmlSinhalaS[] = {{0xd80, 0xdff}};
+
+static const xmlChSRange xmlSmallFormVariantsS[] = {{0xfe50, 0xfe6f}};
+
+static const xmlChSRange xmlSpacingModifierLettersS[] = {{0x2b0, 0x2ff}};
+
+static const xmlChSRange xmlSpecialsS[] = {{0xfff0, 0xffff}};
+
+static const xmlChSRange xmlSuperscriptsandSubscriptsS[] = {{0x2070, 0x209f}};
+
+static const xmlChSRange xmlSupplementalArrowsAS[] = {{0x27f0, 0x27ff}};
+
+static const xmlChSRange xmlSupplementalArrowsBS[] = {{0x2900, 0x297f}};
+
+static const xmlChSRange xmlSupplementalMathematicalOperatorsS[] = {
+    {0x2a00, 0x2aff}};
+
+static const xmlChLRange xmlSupplementaryPrivateUseAreaAL[] = {
+    {0xf0000, 0xfffff}};
+
+static const xmlChLRange xmlSupplementaryPrivateUseAreaBL[] = {
+    {0x100000, 0x10ffff}};
+
+static const xmlChSRange xmlSyriacS[] = {{0x700, 0x74f}};
+
+static const xmlChSRange xmlTagalogS[] = {{0x1700, 0x171f}};
+
+static const xmlChSRange xmlTagbanwaS[] = {{0x1760, 0x177f}};
+
+static const xmlChLRange xmlTagsL[] = {{0xe0000, 0xe007f}};
+
+static const xmlChSRange xmlTaiLeS[] = {{0x1950, 0x197f}};
+
+static const xmlChLRange xmlTaiXuanJingSymbolsL[] = {{0x1d300, 0x1d35f}};
+
+static const xmlChSRange xmlTamilS[] = {{0xb80, 0xbff}};
+
+static const xmlChSRange xmlTeluguS[] = {{0xc00, 0xc7f}};
+
+static const xmlChSRange xmlThaanaS[] = {{0x780, 0x7bf}};
+
+static const xmlChSRange xmlThaiS[] = {{0xe00, 0xe7f}};
+
+static const xmlChSRange xmlTibetanS[] = {{0xf00, 0xfff}};
+
+static const xmlChLRange xmlUgariticL[] = {{0x10380, 0x1039f}};
+
+static const xmlChSRange xmlUnifiedCanadianAboriginalSyllabicsS[] = {
+    {0x1400, 0x167f}};
+
+static const xmlChSRange xmlVariationSelectorsS[] = {{0xfe00, 0xfe0f}};
+
+static const xmlChLRange xmlVariationSelectorsSupplementL[] = {
+    {0xe0100, 0xe01ef}};
+
+static const xmlChSRange xmlYiRadicalsS[] = {{0xa490, 0xa4cf}};
+
+static const xmlChSRange xmlYiSyllablesS[] = {{0xa000, 0xa48f}};
+
+static const xmlChSRange xmlYijingHexagramSymbolsS[] = {{0x4dc0, 0x4dff}};
+
+static const xmlUnicodeRange xmlUnicodeBlocks[] = {
+  {"AegeanNumbers",
+   {0,1,NULL,xmlAegeanNumbersL}},
+  {"AlphabeticPresentationForms",
+   {1,0,xmlAlphabeticPresentationFormsS,NULL}},
+  {"Arabic",
+   {1,0,xmlArabicS,NULL}},
+  {"ArabicPresentationForms-A",
+   {1,0,xmlArabicPresentationFormsAS,NULL}},
+  {"ArabicPresentationForms-B",
+   {1,0,xmlArabicPresentationFormsBS,NULL}},
+  {"Armenian",
+   {1,0,xmlArmenianS,NULL}},
+  {"Arrows",
+   {1,0,xmlArrowsS,NULL}},
+  {"BasicLatin",
+   {1,0,xmlBasicLatinS,NULL}},
+  {"Bengali",
+   {1,0,xmlBengaliS,NULL}},
+  {"BlockElements",
+   {1,0,xmlBlockElementsS,NULL}},
+  {"Bopomofo",
+   {1,0,xmlBopomofoS,NULL}},
+  {"BopomofoExtended",
+   {1,0,xmlBopomofoExtendedS,NULL}},
+  {"BoxDrawing",
+   {1,0,xmlBoxDrawingS,NULL}},
+  {"BraillePatterns",
+   {1,0,xmlBraillePatternsS,NULL}},
+  {"Buhid",
+   {1,0,xmlBuhidS,NULL}},
+  {"ByzantineMusicalSymbols",
+   {0,1,NULL,xmlByzantineMusicalSymbolsL}},
+  {"CJKCompatibility",
+   {1,0,xmlCJKCompatibilityS,NULL}},
+  {"CJKCompatibilityForms",
+   {1,0,xmlCJKCompatibilityFormsS,NULL}},
+  {"CJKCompatibilityIdeographs",
+   {1,0,xmlCJKCompatibilityIdeographsS,NULL}},
+  {"CJKCompatibilityIdeographsSupplement",
+   {0,1,NULL,xmlCJKCompatibilityIdeographsSupplementL}},
+  {"CJKRadicalsSupplement",
+   {1,0,xmlCJKRadicalsSupplementS,NULL}},
+  {"CJKSymbolsandPunctuation",
+   {1,0,xmlCJKSymbolsandPunctuationS,NULL}},
+  {"CJKUnifiedIdeographs",
+   {1,0,xmlCJKUnifiedIdeographsS,NULL}},
+  {"CJKUnifiedIdeographsExtensionA",
+   {1,0,xmlCJKUnifiedIdeographsExtensionAS,NULL}},
+  {"CJKUnifiedIdeographsExtensionB",
+   {0,1,NULL,xmlCJKUnifiedIdeographsExtensionBL}},
+  {"Cherokee",
+   {1,0,xmlCherokeeS,NULL}},
+  {"CombiningDiacriticalMarks",
+   {1,0,xmlCombiningDiacriticalMarksS,NULL}},
+  {"CombiningDiacriticalMarksforSymbols",
+   {1,0,xmlCombiningDiacriticalMarksforSymbolsS,NULL}},
+  {"CombiningHalfMarks",
+   {1,0,xmlCombiningHalfMarksS,NULL}},
+  {"CombiningMarksforSymbols",
+   {1,0,xmlCombiningMarksforSymbolsS,NULL}},
+  {"ControlPictures",
+   {1,0,xmlControlPicturesS,NULL}},
+  {"CurrencySymbols",
+   {1,0,xmlCurrencySymbolsS,NULL}},
+  {"CypriotSyllabary",
+   {0,1,NULL,xmlCypriotSyllabaryL}},
+  {"Cyrillic",
+   {1,0,xmlCyrillicS,NULL}},
+  {"CyrillicSupplement",
+   {1,0,xmlCyrillicSupplementS,NULL}},
+  {"Deseret",
+   {0,1,NULL,xmlDeseretL}},
+  {"Devanagari",
+   {1,0,xmlDevanagariS,NULL}},
+  {"Dingbats",
+   {1,0,xmlDingbatsS,NULL}},
+  {"EnclosedAlphanumerics",
+   {1,0,xmlEnclosedAlphanumericsS,NULL}},
+  {"EnclosedCJKLettersandMonths",
+   {1,0,xmlEnclosedCJKLettersandMonthsS,NULL}},
+  {"Ethiopic",
+   {1,0,xmlEthiopicS,NULL}},
+  {"GeneralPunctuation",
+   {1,0,xmlGeneralPunctuationS,NULL}},
+  {"GeometricShapes",
+   {1,0,xmlGeometricShapesS,NULL}},
+  {"Georgian",
+   {1,0,xmlGeorgianS,NULL}},
+  {"Gothic",
+   {0,1,NULL,xmlGothicL}},
+  {"Greek",
+   {1,0,xmlGreekS,NULL}},
+  {"GreekExtended",
+   {1,0,xmlGreekExtendedS,NULL}},
+  {"GreekandCoptic",
+   {1,0,xmlGreekandCopticS,NULL}},
+  {"Gujarati",
+   {1,0,xmlGujaratiS,NULL}},
+  {"Gurmukhi",
+   {1,0,xmlGurmukhiS,NULL}},
+  {"HalfwidthandFullwidthForms",
+   {1,0,xmlHalfwidthandFullwidthFormsS,NULL}},
+  {"HangulCompatibilityJamo",
+   {1,0,xmlHangulCompatibilityJamoS,NULL}},
+  {"HangulJamo",
+   {1,0,xmlHangulJamoS,NULL}},
+  {"HangulSyllables",
+   {1,0,xmlHangulSyllablesS,NULL}},
+  {"Hanunoo",
+   {1,0,xmlHanunooS,NULL}},
+  {"Hebrew",
+   {1,0,xmlHebrewS,NULL}},
+  {"HighPrivateUseSurrogates",
+   {1,0,xmlHighPrivateUseSurrogatesS,NULL}},
+  {"HighSurrogates",
+   {1,0,xmlHighSurrogatesS,NULL}},
+  {"Hiragana",
+   {1,0,xmlHiraganaS,NULL}},
+  {"IPAExtensions",
+   {1,0,xmlIPAExtensionsS,NULL}},
+  {"IdeographicDescriptionCharacters",
+   {1,0,xmlIdeographicDescriptionCharactersS,NULL}},
+  {"Kanbun",
+   {1,0,xmlKanbunS,NULL}},
+  {"KangxiRadicals",
+   {1,0,xmlKangxiRadicalsS,NULL}},
+  {"Kannada",
+   {1,0,xmlKannadaS,NULL}},
+  {"Katakana",
+   {1,0,xmlKatakanaS,NULL}},
+  {"KatakanaPhoneticExtensions",
+   {1,0,xmlKatakanaPhoneticExtensionsS,NULL}},
+  {"Khmer",
+   {1,0,xmlKhmerS,NULL}},
+  {"KhmerSymbols",
+   {1,0,xmlKhmerSymbolsS,NULL}},
+  {"Lao",
+   {1,0,xmlLaoS,NULL}},
+  {"Latin-1Supplement",
+   {1,0,xmlLatin1SupplementS,NULL}},
+  {"LatinExtended-A",
+   {1,0,xmlLatinExtendedAS,NULL}},
+  {"LatinExtended-B",
+   {1,0,xmlLatinExtendedBS,NULL}},
+  {"LatinExtendedAdditional",
+   {1,0,xmlLatinExtendedAdditionalS,NULL}},
+  {"LetterlikeSymbols",
+   {1,0,xmlLetterlikeSymbolsS,NULL}},
+  {"Limbu",
+   {1,0,xmlLimbuS,NULL}},
+  {"LinearBIdeograms",
+   {0,1,NULL,xmlLinearBIdeogramsL}},
+  {"LinearBSyllabary",
+   {0,1,NULL,xmlLinearBSyllabaryL}},
+  {"LowSurrogates",
+   {1,0,xmlLowSurrogatesS,NULL}},
+  {"Malayalam",
+   {1,0,xmlMalayalamS,NULL}},
+  {"MathematicalAlphanumericSymbols",
+   {0,1,NULL,xmlMathematicalAlphanumericSymbolsL}},
+  {"MathematicalOperators",
+   {1,0,xmlMathematicalOperatorsS,NULL}},
+  {"MiscellaneousMathematicalSymbols-A",
+   {1,0,xmlMiscellaneousMathematicalSymbolsAS,NULL}},
+  {"MiscellaneousMathematicalSymbols-B",
+   {1,0,xmlMiscellaneousMathematicalSymbolsBS,NULL}},
+  {"MiscellaneousSymbols",
+   {1,0,xmlMiscellaneousSymbolsS,NULL}},
+  {"MiscellaneousSymbolsandArrows",
+   {1,0,xmlMiscellaneousSymbolsandArrowsS,NULL}},
+  {"MiscellaneousTechnical",
+   {1,0,xmlMiscellaneousTechnicalS,NULL}},
+  {"Mongolian",
+   {1,0,xmlMongolianS,NULL}},
+  {"MusicalSymbols",
+   {0,1,NULL,xmlMusicalSymbolsL}},
+  {"Myanmar",
+   {1,0,xmlMyanmarS,NULL}},
+  {"NumberForms",
+   {1,0,xmlNumberFormsS,NULL}},
+  {"Ogham",
+   {1,0,xmlOghamS,NULL}},
+  {"OldItalic",
+   {0,1,NULL,xmlOldItalicL}},
+  {"OpticalCharacterRecognition",
+   {1,0,xmlOpticalCharacterRecognitionS,NULL}},
+  {"Oriya",
+   {1,0,xmlOriyaS,NULL}},
+  {"Osmanya",
+   {0,1,NULL,xmlOsmanyaL}},
+  {"PhoneticExtensions",
+   {1,0,xmlPhoneticExtensionsS,NULL}},
+  {"PrivateUse",
+   {1,2,xmlPrivateUseS,xmlPrivateUseL}},
+  {"PrivateUseArea",
+   {1,0,xmlPrivateUseAreaS,NULL}},
+  {"Runic",
+   {1,0,xmlRunicS,NULL}},
+  {"Shavian",
+   {0,1,NULL,xmlShavianL}},
+  {"Sinhala",
+   {1,0,xmlSinhalaS,NULL}},
+  {"SmallFormVariants",
+   {1,0,xmlSmallFormVariantsS,NULL}},
+  {"SpacingModifierLetters",
+   {1,0,xmlSpacingModifierLettersS,NULL}},
+  {"Specials",
+   {1,0,xmlSpecialsS,NULL}},
+  {"SuperscriptsandSubscripts",
+   {1,0,xmlSuperscriptsandSubscriptsS,NULL}},
+  {"SupplementalArrows-A",
+   {1,0,xmlSupplementalArrowsAS,NULL}},
+  {"SupplementalArrows-B",
+   {1,0,xmlSupplementalArrowsBS,NULL}},
+  {"SupplementalMathematicalOperators",
+   {1,0,xmlSupplementalMathematicalOperatorsS,NULL}},
+  {"SupplementaryPrivateUseArea-A",
+   {0,1,NULL,xmlSupplementaryPrivateUseAreaAL}},
+  {"SupplementaryPrivateUseArea-B",
+   {0,1,NULL,xmlSupplementaryPrivateUseAreaBL}},
+  {"Syriac",
+   {1,0,xmlSyriacS,NULL}},
+  {"Tagalog",
+   {1,0,xmlTagalogS,NULL}},
+  {"Tagbanwa",
+   {1,0,xmlTagbanwaS,NULL}},
+  {"Tags",
+   {0,1,NULL,xmlTagsL}},
+  {"TaiLe",
+   {1,0,xmlTaiLeS,NULL}},
+  {"TaiXuanJingSymbols",
+   {0,1,NULL,xmlTaiXuanJingSymbolsL}},
+  {"Tamil",
+   {1,0,xmlTamilS,NULL}},
+  {"Telugu",
+   {1,0,xmlTeluguS,NULL}},
+  {"Thaana",
+   {1,0,xmlThaanaS,NULL}},
+  {"Thai",
+   {1,0,xmlThaiS,NULL}},
+  {"Tibetan",
+   {1,0,xmlTibetanS,NULL}},
+  {"Ugaritic",
+   {0,1,NULL,xmlUgariticL}},
+  {"UnifiedCanadianAboriginalSyllabics",
+   {1,0,xmlUnifiedCanadianAboriginalSyllabicsS,NULL}},
+  {"VariationSelectors",
+   {1,0,xmlVariationSelectorsS,NULL}},
+  {"VariationSelectorsSupplement",
+   {0,1,NULL,xmlVariationSelectorsSupplementL}},
+  {"YiRadicals",
+   {1,0,xmlYiRadicalsS,NULL}},
+  {"YiSyllables",
+   {1,0,xmlYiSyllablesS,NULL}},
+  {"YijingHexagramSymbols",
+   {1,0,xmlYijingHexagramSymbolsS,NULL}}
+};
+

codegen/xmlmod.py

@@ -0,0 +1,146 @@
+# Symbol to module mapping
+#
+# This relies on a few tables and some regexes.
+
+import re
+
+moduleMap = {
+    'HTMLtree': 'HTML',
+    'HTMLparser': 'HTML',
+    'c14n': 'C14N',
+    'catalog': 'CATALOG',
+    'debugXML': 'DEBUG',
+    'nanohttp': 'HTTP',
+    'pattern': 'PATTERN',
+    'relaxng': 'RELAXNG',
+    'schemasInternals': 'SCHEMAS',
+    'schematron': 'SCHEMATRON',
+    'xinclude': 'XINCLUDE',
+    'xlink': 'XPTR',
+    'xmlautomata': 'REGEXP',
+    'xmlmodule': 'MODULES',
+    'xmlreader': 'READER',
+    'xmlregexp': 'REGEXP',
+    'xmlsave': 'OUTPUT',
+    'xmlschemas': 'SCHEMAS',
+    'xmlschemastypes': 'SCHEMAS',
+    'xmlwriter': 'WRITER',
+    'xpath': 'XPATH',
+    'xpathInternals': 'XPATH',
+    'xpointer': 'XPTR',
+}
+
+symbolMap1 = {
+    # not VALID
+    'xmlValidateNCName': '',
+    'xmlValidateNMToken': '',
+    'xmlValidateName': '',
+    'xmlValidateQName': '',
+
+    'htmlDefaultSAXHandlerInit': 'HTML',
+    'xmlSAX2InitHtmlDefaultSAXHandler': 'HTML',
+
+    'xmlRegisterHTTPPostCallbacks': 'HTTP',
+
+    '__xmlOutputBufferCreateFilename': 'OUTPUT',
+    'xmlAttrSerializeTxtContent': 'OUTPUT',
+    'xmlUTF8ToIsolat1': 'OUTPUT',
+    'xmlSprintfElementContent': 'OUTPUT',
+
+    'xmlCreatePushParserCtxt': 'PUSH',
+    'xmlParseChunk': 'PUSH',
+
+    'xmlParseBalancedChunkMemory': 'SAX1',
+    'xmlParseBalancedChunkMemoryRecover': 'SAX1',
+    'xmlParseDoc': 'SAX1',
+    'xmlParseEntity': 'SAX1',
+    'xmlParseExternalEntity': 'SAX1',
+    'xmlParseFile': 'SAX1',
+    'xmlParseMemory': 'SAX1',
+    'xmlSAXDefaultVersion': 'SAX1',
+    'xmlSetupParserForBuffer': 'SAX1',
+
+    'xmlCtxtGetValidCtxt': 'VALID',
+    'xmlFreeValidCtxt': 'VALID',
+    'xmlNewValidCtxt': 'VALID',
+
+    'xmlCatalogConvert': 'SGML_CATALOG',
+    'xmlConvertSGMLCatalog': 'SGML_CATALOG',
+    'xmlLoadSGMLSuperCatalog': 'SGML_CATALOG',
+}
+
+symbolMap2 = {
+    # not OUTPUT (should be fixed in xmlIO.h)
+    'xmlOutputBufferCreateFilenameDefault': '',
+
+    'xmlXPathDebugDumpCompExpr': 'DEBUG',
+    'xmlXPathDebugDumpObject': 'DEBUG',
+    'xmlSchemaDump': 'DEBUG',
+    'xmlRelaxNGDump': 'DEBUG',
+
+    'xmlACatalogDump': 'OUTPUT',
+    'xmlCatalogDump': 'OUTPUT',
+    'xmlIOHTTPOpenW': 'OUTPUT',
+    'xmlNanoHTTPSave': 'OUTPUT',
+    'xmlRegisterHTTPPostCallbacks': 'OUTPUT',
+    'xmlRelaxNGDumpTree': 'OUTPUT',
+
+    'xmlTextReaderPreservePattern': 'PATTERN',
+
+    'htmlCreatePushParserCtxt': 'PUSH',
+    'htmlParseChunk': 'PUSH',
+
+    'xmlValidBuildContentModel': 'REGEXP',
+    'xmlValidatePopElement': 'REGEXP',
+    'xmlValidatePushCData': 'REGEXP',
+    'xmlValidatePushElement': 'REGEXP',
+
+    'xmlTextReaderRelaxNGSetSchema': 'RELAXNG',
+    'xmlTextReaderRelaxNGValidate': 'RELAXNG',
+    'xmlTextReaderRelaxNGValidateCtxt': 'RELAXNG',
+
+    'xmlTextReaderSchemaValidate': 'SCHEMAS',
+    'xmlTextReaderSchemaValidateCtxt': 'SCHEMAS',
+    'xmlTextReaderSetSchema': 'SCHEMAS',
+
+    'xmlTextReaderReadInnerXml': 'WRITER',
+    'xmlTextReaderReadOuterXml': 'WRITER',
+}
+
+outputRegex = '|'.join((
+    '^(html|xml(Buf)?)(Doc(Content|Format)?|Elem|Node)Dump',
+    '^(html|xml)Save(Format)?File',
+    '^xmlDump.*(Decl|Table)',
+    '^xml(Alloc)?OutputBuffer',
+    '^xml.*OutputCallbacks',
+))
+
+def findModules(filename, symbol):
+    module1 = symbolMap1.get(symbol)
+
+    if module1 is None:
+        module1 = moduleMap.get(filename)
+
+    if module1 is None:
+        if re.search('^xml(Ctxt)?Valid|Parse(DTD|Dtd)', symbol):
+            module1 = 'VALID'
+        elif re.search('^xml(Recover|SAX(User)?Parse)', symbol):
+            module1 = 'SAX1'
+        elif re.search('^xmlIOHTTP', symbol):
+            module1 = 'HTTP'
+
+    module2 = symbolMap2.get(symbol)
+
+    if module2 is None:
+        if re.search(outputRegex, symbol):
+            if module1 is None:
+                module1 = 'OUTPUT'
+            else:
+                module2 = 'OUTPUT'
+
+    if module1 is None:
+        module1 = ''
+    if module2 is None:
+        module2 = ''
+
+    return module1, module2