MFV r355071: libbsdxml (expat) 2.2.9.

MFC after: 2 weeks Relnotes: yes
author: Xin LI <delphij@FreeBSD.org> 2019-11-25 07:48:16 +0000
committer: Xin LI <delphij@FreeBSD.org> 2019-11-25 07:48:16 +0000
commit: 6b2c1e49da284f28ec7b52f7c031474087e37104 (patch)
tree: 1c6eabb549a0be6167f4f25f3e388afa0f730197 /contrib/expat
parent: 6a14746c01a91a9f33f67d79565d01d96a879a3a (diff)
parent: 987ba809b8add6260181a8c036ec3c017948ff56 (diff)
download: src-test2-6b2c1e49da284f28ec7b52f7c031474087e37104.tar.gz
src-test2-6b2c1e49da284f28ec7b52f7c031474087e37104.zip
62 files changed, 13829 insertions, 14870 deletions
diff --git a/contrib/expat/Changes b/contrib/expat/Changes
index b0ee42cd36cf..340947118a3f 100644
--- a/contrib/expat/Changes
+++ b/contrib/expat/Changes
@@ -2,6 +2,162 @@ NOTE: We are looking for help with a few things:
       https://github.com/libexpat/libexpat/labels/help%20wanted
       If you can help, please get in touch.  Thanks!
 
+Release 2.2.9 Wed Septemper 25 2019
+        Other changes:
+                  examples: Drop executable bits from elements.c
+            #349  Windows: Change the name of the Windows DLLs from expat*.dll
+                    to libexpat*.dll once more (regression from 2.2.8, first
+                    fixed in 1.95.3, issue #61 on SourceForge today,
+                    was issue #432456 back then); needs a fix due
+                    case-insensitive file systems on Windows and the fact that
+                    Perl's XML::Parser::Expat compiles into Expat.dll.
+            #347  Windows: Only define _CRT_RAND_S if not defined
+                  Version info bumped from 7:10:6 to 7:11:6
+
+        Special thanks to:
+            Ben Wagner
+
+Release 2.2.8 Fri Septemper 13 2019
+        Security fixes:
+       #317 #318  CVE-2019-15903 -- Fix heap overflow triggered by
+                    XML_GetCurrentLineNumber (or XML_GetCurrentColumnNumber),
+                    and deny internal entities closing the doctype;
+                    fixed in commit c20b758c332d9a13afbbb276d30db1d183a85d43
+
+        Bug fixes:
+            #240  Fix cases where XML_StopParser did not have any effect
+                    when called from inside of an end element handler
+            #341  xmlwf: Fix exit code for operation without "-d DIRECTORY";
+                    previously, only "-d DIRECTORY" would give you a proper
+                    exit code:
+                      # xmlwf -d . <<<'<not well-formed>' 2>/dev/null ; echo $?
+                      2
+                      # xmlwf <<<'<not well-formed>' 2>/dev/null ; echo $?
+                      0
+                    Now both cases return exit code 2.
+
+        Other changes:
+       #299 #302  Windows: Replace LoadLibrary hack to access
+                    unofficial API function SystemFunction036 (RtlGenRandom)
+                    by using official API function rand_s (needs WinXP+)
+            #325  Windows: Drop support for Visual Studio <=7.1/2003
+                    and document supported compilers in README.md
+            #286  Windows: Remove COM code from xmlwf; in case it turns
+                    out needed later, there will be a dedicated repository
+                    below https://github.com/libexpat/ for that code
+            #322  Windows: Remove explicit MSVC solution and project files.
+                    You can generate Visual Studio solution files through
+                    CMake, e.g.: cmake -G"Visual Studio 15 2017" .
+            #338  xmlwf: Make "xmlwf -h" help output more friendly
+            #339  examples: Improve elements.c
+       #244 #264  Autotools: Add argument --enable-xml-attr-info
+       #239 #301  Autotools: Add arguments
+                    --with-getrandom
+                    --without-getrandom
+                    --with-sys-getrandom
+                    --without-sys-getrandom
+       #312 #343  Autotools: Fix linking issues with "./configure LD=clang"
+                  Autotools: Fix "make run-xmltest" for out-of-source builds
+       #329 #336  CMake: Pull all options from Expat <=2.2.7 into namespace
+                    prefix EXPAT_ with the exception of DOCBOOK_TO_MAN:
+                    - BUILD_doc            -> EXPAT_BUILD_DOCS (plural)
+                    - BUILD_examples       -> EXPAT_BUILD_EXAMPLES
+                    - BUILD_shared         -> EXPAT_SHARED_LIBS
+                    - BUILD_tests          -> EXPAT_BUILD_TESTS
+                    - BUILD_tools          -> EXPAT_BUILD_TOOLS
+                    - DOCBOOK_TO_MAN       -> DOCBOOK_TO_MAN (unchanged)
+                    - INSTALL              -> EXPAT_ENABLE_INSTALL
+                    - MSVC_USE_STATIC_CRT  -> EXPAT_MSVC_STATIC_CRT
+                    - USE_libbsd           -> EXPAT_WITH_LIBBSD
+                    - WARNINGS_AS_ERRORS   -> EXPAT_WARNINGS_AS_ERRORS
+                    - XML_CONTEXT_BYTES    -> EXPAT_CONTEXT_BYTES
+                    - XML_DEV_URANDOM      -> EXPAT_DEV_URANDOM
+                    - XML_DTD              -> EXPAT_DTD
+                    - XML_NS               -> EXPAT_NS
+                    - XML_UNICODE          -> EXPAT_CHAR_TYPE=ushort (!)
+                    - XML_UNICODE_WCHAR_T  -> EXPAT_CHAR_TYPE=wchar_t (!)
+       #244 #264  CMake: Add argument -DEXPAT_ATTR_INFO=(ON|OFF),
+                    default OFF
+            #326  CMake: Add argument -DEXPAT_LARGE_SIZE=(ON|OFF),
+                    default OFF
+            #328  CMake: Add argument -DEXPAT_MIN_SIZE=(ON|OFF),
+                    default OFF
+       #239 #277  CMake: Add arguments
+                    -DEXPAT_WITH_GETRANDOM=(ON|OFF|AUTO), default AUTO
+                    -DEXPAT_WITH_SYS_GETRANDOM=(ON|OFF|AUTO), default AUTO
+            #326  CMake: Install expat_config.h to include directory
+            #326  CMake: Generate and install configuration files for
+                    future find_package(expat [..] CONFIG [..])
+                  CMake: Now produces a summary of applied configuration
+                  CMake: Require C++ compiler only when tests are enabled
+            #330  CMake: Fix compilation for 16bit character types,
+                    i.e. ex -DXML_UNICODE=ON (and ex -DXML_UNICODE_WCHAR_T=ON)
+            #265  CMake: Fix linking with MinGW
+            #330  CMake: Add full support for MinGW; to enable, use
+                    -DCMAKE_TOOLCHAIN_FILE=[expat]/cmake/mingw-toolchain.cmake
+            #330  CMake: Port "make run-xmltest" from GNU Autotools to CMake
+            #316  CMake: Windows: Make binary postfix match MSVC
+                    Old: expat[d].lib
+                    New: expat[w][d][MD|MT].lib
+                  CMake: Migrate files from Windows to Unix line endings
+            #308  CMake: Integrate OSS-Fuzz fuzzers, option
+                    -DEXPAT_BUILD_FUZZERS=(ON|OFF), default OFF
+             #14  Drop an OpenVMS support leftover
+    #235 #268 ..
+    #270 #310 ..
+  #313 #331 #333  Address compiler warnings
+    #282 #283 ..
+       #284 #285  Address cppcheck warnings
+       #294 #295  Address Clang Static Analyzer warnings
+        #24 #293  Mass-apply clang-format 9 (and ensure conformance during CI)
+                  Version info bumped from 7:9:6 to 7:10:6
+
+        Special thanks to:
+            David Loffredo
+            Joonun Jang
+            Khajapasha Mohammed
+            Kishore Kunche
+            Marco Maggi
+            Mitch Phillips
+            Rolf Ade
+            xantares
+            Zhongyuan Zhou
+
+Release 2.2.7 Wed June 19 2019
+        Security fixes:
+       #186 #262  CVE-2018-20843 -- Fix extraction of namespace prefixes from
+                    XML names; XML names with multiple colons could end up in
+                    the wrong namespace, and take a high amount of RAM and CPU
+                    resources while processing, opening the door to
+                    use for denial-of-service attacks
+
+        Other changes:
+       #195 #197  Autotools/CMake: Utilize -fvisibility=hidden to stop
+                    exporting non-API symbols
+            #227  Autotools: Add --without-examples and --without-tests
+            #228  Autotools: Modernize configure.ac
+       #245 #246  Autotools: Fix check for -fvisibility=hidden for Clang
+       #247 #248  Autotools: Fix compilation for lack of docbook2x-man
+       #236 #258  Autotools: Produce .tar.{gz,lz,xz} release archives
+            #212  CMake: Make libdir of pkgconfig expat.pc support multilib
+       #158 #263  CMake: Build man page in PROJECT_BINARY_DIR not _SOURCE_DIR
+            #219  Remove fallback to bcopy, assume that memmove(3) exists
+            #257  Use portable "/usr/bin/env bash" shebang (e.g. for OpenBSD)
+            #243  Windows: Fix syntax of .def module definition files
+                  Version info bumped from 7:8:6 to 7:9:6
+
+        Special thanks to:
+            Benjamin Peterson
+            Caolán McNamara
+            Hanno Böck
+            KangLin
+            Kishore Kunche
+            Marco Maggi
+            Rhodri James
+            Sebastian Dröge
+            userwithuid
+            Yury Gribov
+
 Release 2.2.6 Sun August 12 2018
         Bug fixes:
        #170 #206  Avoid doing arithmetic with NULL pointers in XML_GetBuffer
diff --git a/contrib/expat/FREEBSD-Xlist b/contrib/expat/FREEBSD-Xlist
index d5b4f670b696..c1f2a689fee4 100644
--- a/contrib/expat/FREEBSD-Xlist
+++ b/contrib/expat/FREEBSD-Xlist
@@ -8,6 +8,7 @@
 *.pc.in
 *.vcxproj*
 *config.h
+cmake
 CMake*
 Configure*
 amiga
diff --git a/contrib/expat/Makefile.am b/contrib/expat/Makefile.am
index 5ed9ac410a42..5e1d37dd1a83 100644
--- a/contrib/expat/Makefile.am
+++ b/contrib/expat/Makefile.am
@@ -30,14 +30,21 @@
 
 AUTOMAKE_OPTIONS = \
     dist-bzip2 \
+    dist-lzip \
+    dist-xz \
     foreign \
-    no-dist-gzip \
     subdir-objects
 
 ACLOCAL_AMFLAGS = -I m4
 LIBTOOLFLAGS = --verbose
 
-SUBDIRS = lib examples tests  # lib goes first to build first
+SUBDIRS = lib # lib goes first to build first
+if WITH_EXAMPLES
+SUBDIRS += examples
+endif
+if WITH_TESTS
+SUBDIRS += tests  
+endif
 if WITH_XMLWF
 SUBDIRS += xmlwf doc
 endif
@@ -47,41 +54,19 @@ pkgconfigdir = $(libdir)/pkgconfig
 
 
 _EXTRA_DIST_CMAKE = \
+    cmake/expat-config.cmake.in \
+    cmake/mingw-toolchain.cmake \
+    \
     CMakeLists.txt \
     CMake.README \
     ConfigureChecks.cmake \
     expat_config.h.cmake
 
 _EXTRA_DIST_WINDOWS = \
-    examples/elements.vcxproj \
-    examples/elements.vcxproj.filters \
-    examples/outline.vcxproj \
-    examples/outline.vcxproj.filters \
-    \
-    lib/expat_static.vcxproj \
-    lib/expat_static.vcxproj.filters \
-    lib/expat.vcxproj \
-    lib/expat.vcxproj.filters \
-    lib/expatw_static.vcxproj \
-    lib/expatw_static.vcxproj.filters \
-    lib/expatw.vcxproj \
-    lib/expatw.vcxproj.filters \
-    \
-    tests/benchmark/benchmark.sln \
-    tests/benchmark/benchmark.vcxproj \
-    \
-    tests/runtests.sln \
-    tests/runtests.vcxproj \
-    tests/runtests.vcxproj.filters \
-    \
+    win32/build_expat_iss.bat \
     win32/expat.iss \
     win32/MANIFEST.txt \
-    win32/README.txt \
-    \
-    xmlwf/xmlwf.vcxproj \
-    xmlwf/xmlwf.vcxproj.filters \
-    \
-    expat.sln
+    win32/README.txt
 
 EXTRA_DIST = \
     $(_EXTRA_DIST_CMAKE) \
@@ -91,8 +76,13 @@ EXTRA_DIST = \
     conftools/get-version.sh \
     conftools/PrintPath \
     \
+    xmlwf/xmlwf_helpgen.py \
+    xmlwf/xmlwf_helpgen.sh \
+    \
     Changes \
     README.md \
+    \
+    fix-xmltest-log.sh \
     test-driver-wrapper.sh
 
 
@@ -121,7 +111,8 @@ run-benchmark:
 	$(MAKE) -C tests/benchmark
 	./run.sh tests/benchmark/benchmark@EXEEXT@ -n $(top_srcdir)/../testdata/largefiles/recset.xml 65535 3
 
-tests/xmlts.zip:
+.PHONY: download-xmlts-zip
+download-xmlts-zip:
 	if test "$(XMLTS_ZIP)" = ""; then \
 		wget --output-document=tests/xmlts.zip \
 			https://www.w3.org/XML/Test/xmlts20080827.zip; \
@@ -129,16 +120,26 @@ tests/xmlts.zip:
 		cp $(XMLTS_ZIP) tests/xmlts.zip; \
 	fi
 
-tests/xmlconf: tests/xmlts.zip
+tests/xmlts.zip:
+	$(MAKE) download-xmlts-zip
+
+.PHONY: extract-xmlts-zip
+extract-xmlts-zip: tests/xmlts.zip
+	[ -f $(builddir)/tests/xmlts.zip ] || $(MAKE) download-xmlts-zip  # vpath workaround
 	cd tests && unzip -q xmlts.zip
 
+tests/xmlconf: tests/xmlts.zip
+	$(MAKE) extract-xmlts-zip
+
 .PHONY: run-xmltest
 run-xmltest: tests/xmlconf
 if WITH_XMLWF
+	[ -d $(builddir)/tests/xmlconf ] || $(MAKE) extract-xmlts-zip  # vpath workaround
+	$(MAKE) -C lib
 	$(MAKE) -C xmlwf
-	tests/xmltest.sh "$(PWD)/run.sh $(PWD)/xmlwf/xmlwf@EXEEXT@" 2>&1 | tee tests/xmltest.log
-	dos2unix tests/xmltest.log
-	diff -u tests/xmltest.log.expected tests/xmltest.log
+	$(srcdir)/tests/xmltest.sh "$(abs_builddir)/run.sh $(abs_builddir)/xmlwf/xmlwf@EXEEXT@" 2>&1 | tee $(builddir)/tests/xmltest.log
+	$(srcdir)/fix-xmltest-log.sh $(builddir)/tests/xmltest.log
+	diff -u $(srcdir)/tests/xmltest.log.expected $(builddir)/tests/xmltest.log
 else
 	@echo 'ERROR: xmlwf is needed for "make run-xmltest".' >&2
 	@echo 'ERROR: Please re-configure without --without-xmlwf.' >&2
@@ -147,7 +148,7 @@ endif
 
 .PHONY: qa
 qa:
-	./qa.sh address
-	./qa.sh memory
-	./qa.sh undefined
-	./qa.sh coverage
+	QA_COMPILER=clang QA_SANITIZER=address   ./qa.sh
+	QA_COMPILER=clang QA_SANITIZER=memory    ./qa.sh
+	QA_COMPILER=clang QA_SANITIZER=undefined ./qa.sh
+	QA_COMPILER=gcc   QA_PROCESSOR=gcov      ./qa.sh
diff --git a/contrib/expat/Makefile.in b/contrib/expat/Makefile.in
index 9560a955aa81..89bf68febc48 100644
--- a/contrib/expat/Makefile.in
+++ b/contrib/expat/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -118,13 +118,22 @@ PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
-@WITH_XMLWF_TRUE@am__append_1 = xmlwf doc
+@WITH_EXAMPLES_TRUE@am__append_1 = examples
+@WITH_TESTS_TRUE@am__append_2 = tests  
+@WITH_XMLWF_TRUE@am__append_3 = xmlwf doc
 subdir = .
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -199,7 +208,7 @@ am__recursive_targets = \
   $(RECURSIVE_CLEAN_TARGETS) \
   $(am__extra_recursive_targets)
 AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
-	cscope distdir dist dist-all distcheck
+	cscope distdir distdir-am dist dist-all distcheck
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
 	$(LISP)expat_config.h.in
 # Read a list of newline-separated strings from the standard input,
@@ -224,14 +233,15 @@ CSCOPE = cscope
 DIST_SUBDIRS = lib examples tests xmlwf doc
 am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/expat.pc.in \
 	$(srcdir)/expat_config.h.in $(srcdir)/run.sh.in \
-	$(top_srcdir)/conftools/compile \
+	$(top_srcdir)/conftools/ar-lib $(top_srcdir)/conftools/compile \
 	$(top_srcdir)/conftools/config.guess \
 	$(top_srcdir)/conftools/config.sub \
 	$(top_srcdir)/conftools/install-sh \
 	$(top_srcdir)/conftools/ltmain.sh \
 	$(top_srcdir)/conftools/missing AUTHORS COPYING \
-	conftools/compile conftools/config.guess conftools/config.sub \
-	conftools/install-sh conftools/ltmain.sh conftools/missing
+	conftools/ar-lib conftools/compile conftools/config.guess \
+	conftools/config.sub conftools/depcomp conftools/install-sh \
+	conftools/ltmain.sh conftools/missing
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
@@ -267,9 +277,10 @@ am__relativize = \
     dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
   done; \
   reldir="$$dir2"
+DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 $(distdir).tar.lz \
+	$(distdir).tar.xz
 GZIP_ENV = --best
-DIST_ARCHIVES = $(distdir).tar.bz2
-DIST_TARGETS = dist-bzip2
+DIST_TARGETS = dist-lzip dist-xz dist-bzip2 dist-gzip
 distuninstallcheck_listfiles = find . -type f -print
 am__distuninstallcheck_listfiles = $(distuninstallcheck_listfiles) \
   | sed 's|^\./|$(prefix)/|' | grep -v '$(infodir)/dir$$'
@@ -402,51 +413,30 @@ top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 AUTOMAKE_OPTIONS = \
     dist-bzip2 \
+    dist-lzip \
+    dist-xz \
     foreign \
-    no-dist-gzip \
     subdir-objects
 
 ACLOCAL_AMFLAGS = -I m4
 LIBTOOLFLAGS = --verbose
-SUBDIRS = lib examples tests $(am__append_1)
+SUBDIRS = lib $(am__append_1) $(am__append_2) $(am__append_3)
 pkgconfig_DATA = expat.pc
 pkgconfigdir = $(libdir)/pkgconfig
 _EXTRA_DIST_CMAKE = \
+    cmake/expat-config.cmake.in \
+    cmake/mingw-toolchain.cmake \
+    \
     CMakeLists.txt \
     CMake.README \
     ConfigureChecks.cmake \
     expat_config.h.cmake
 
 _EXTRA_DIST_WINDOWS = \
-    examples/elements.vcxproj \
-    examples/elements.vcxproj.filters \
-    examples/outline.vcxproj \
-    examples/outline.vcxproj.filters \
-    \
-    lib/expat_static.vcxproj \
-    lib/expat_static.vcxproj.filters \
-    lib/expat.vcxproj \
-    lib/expat.vcxproj.filters \
-    lib/expatw_static.vcxproj \
-    lib/expatw_static.vcxproj.filters \
-    lib/expatw.vcxproj \
-    lib/expatw.vcxproj.filters \
-    \
-    tests/benchmark/benchmark.sln \
-    tests/benchmark/benchmark.vcxproj \
-    \
-    tests/runtests.sln \
-    tests/runtests.vcxproj \
-    tests/runtests.vcxproj.filters \
-    \
+    win32/build_expat_iss.bat \
     win32/expat.iss \
     win32/MANIFEST.txt \
-    win32/README.txt \
-    \
-    xmlwf/xmlwf.vcxproj \
-    xmlwf/xmlwf.vcxproj.filters \
-    \
-    expat.sln
+    win32/README.txt
 
 EXTRA_DIST = \
     $(_EXTRA_DIST_CMAKE) \
@@ -456,8 +446,13 @@ EXTRA_DIST = \
     conftools/get-version.sh \
     conftools/PrintPath \
     \
+    xmlwf/xmlwf_helpgen.py \
+    xmlwf/xmlwf_helpgen.sh \
+    \
     Changes \
     README.md \
+    \
+    fix-xmltest-log.sh \
     test-driver-wrapper.sh
 
 all: expat_config.h
@@ -485,8 +480,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	    echo ' $(SHELL) ./config.status'; \
 	    $(SHELL) ./config.status;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -653,7 +648,10 @@ distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 	-rm -f cscope.out cscope.in.out cscope.po.out cscope.files
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	$(am__remove_distdir)
 	test -d "$(distdir)" || mkdir "$(distdir)"
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
@@ -723,11 +721,9 @@ dist-gzip: distdir
 dist-bzip2: distdir
 	tardir=$(distdir) && $(am__tar) | BZIP2=$${BZIP2--9} bzip2 -c >$(distdir).tar.bz2
 	$(am__post_remove_distdir)
-
 dist-lzip: distdir
 	tardir=$(distdir) && $(am__tar) | lzip -c $${LZIP_OPT--9} >$(distdir).tar.lz
 	$(am__post_remove_distdir)
-
 dist-xz: distdir
 	tardir=$(distdir) && $(am__tar) | XZ_OPT=$${XZ_OPT--e} xz -c >$(distdir).tar.xz
 	$(am__post_remove_distdir)
@@ -994,7 +990,8 @@ run-benchmark:
 	$(MAKE) -C tests/benchmark
 	./run.sh tests/benchmark/benchmark@EXEEXT@ -n $(top_srcdir)/../testdata/largefiles/recset.xml 65535 3
 
-tests/xmlts.zip:
+.PHONY: download-xmlts-zip
+download-xmlts-zip:
 	if test "$(XMLTS_ZIP)" = ""; then \
 		wget --output-document=tests/xmlts.zip \
 			https://www.w3.org/XML/Test/xmlts20080827.zip; \
@@ -1002,25 +999,35 @@ tests/xmlts.zip:
 		cp $(XMLTS_ZIP) tests/xmlts.zip; \
 	fi
 
-tests/xmlconf: tests/xmlts.zip
+tests/xmlts.zip:
+	$(MAKE) download-xmlts-zip
+
+.PHONY: extract-xmlts-zip
+extract-xmlts-zip: tests/xmlts.zip
+	[ -f $(builddir)/tests/xmlts.zip ] || $(MAKE) download-xmlts-zip  # vpath workaround
 	cd tests && unzip -q xmlts.zip
 
+tests/xmlconf: tests/xmlts.zip
+	$(MAKE) extract-xmlts-zip
+
 .PHONY: run-xmltest
 run-xmltest: tests/xmlconf
+@WITH_XMLWF_TRUE@	[ -d $(builddir)/tests/xmlconf ] || $(MAKE) extract-xmlts-zip  # vpath workaround
+@WITH_XMLWF_TRUE@	$(MAKE) -C lib
 @WITH_XMLWF_TRUE@	$(MAKE) -C xmlwf
-@WITH_XMLWF_TRUE@	tests/xmltest.sh "$(PWD)/run.sh $(PWD)/xmlwf/xmlwf@EXEEXT@" 2>&1 | tee tests/xmltest.log
-@WITH_XMLWF_TRUE@	dos2unix tests/xmltest.log
-@WITH_XMLWF_TRUE@	diff -u tests/xmltest.log.expected tests/xmltest.log
+@WITH_XMLWF_TRUE@	$(srcdir)/tests/xmltest.sh "$(abs_builddir)/run.sh $(abs_builddir)/xmlwf/xmlwf@EXEEXT@" 2>&1 | tee $(builddir)/tests/xmltest.log
+@WITH_XMLWF_TRUE@	$(srcdir)/fix-xmltest-log.sh $(builddir)/tests/xmltest.log
+@WITH_XMLWF_TRUE@	diff -u $(srcdir)/tests/xmltest.log.expected $(builddir)/tests/xmltest.log
 @WITH_XMLWF_FALSE@	@echo 'ERROR: xmlwf is needed for "make run-xmltest".' >&2
 @WITH_XMLWF_FALSE@	@echo 'ERROR: Please re-configure without --without-xmlwf.' >&2
 @WITH_XMLWF_FALSE@	@false
 
 .PHONY: qa
 qa:
-	./qa.sh address
-	./qa.sh memory
-	./qa.sh undefined
-	./qa.sh coverage
+	QA_COMPILER=clang QA_SANITIZER=address   ./qa.sh
+	QA_COMPILER=clang QA_SANITIZER=memory    ./qa.sh
+	QA_COMPILER=clang QA_SANITIZER=undefined ./qa.sh
+	QA_COMPILER=gcc   QA_PROCESSOR=gcov      ./qa.sh
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
diff --git a/contrib/expat/README.md b/contrib/expat/README.md
index 2c7e6ac40506..1cc52b014489 100644
--- a/contrib/expat/README.md
+++ b/contrib/expat/README.md
@@ -1,8 +1,9 @@
 [![Travis CI Build Status](https://travis-ci.org/libexpat/libexpat.svg?branch=master)](https://travis-ci.org/libexpat/libexpat)
 [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/libexpat/libexpat?svg=true)](https://ci.appveyor.com/project/libexpat/libexpat)
+[![Packaging status](https://repology.org/badge/tiny-repos/expat.svg)](https://repology.org/metapackage/expat/versions)
 
 
-# Expat, Release 2.2.6
+# Expat, Release 2.2.9
 
 This is Expat, a C library for parsing XML, started by
 [James Clark](https://en.wikipedia.org/wiki/James_Clark_(programmer)) in 1997.
@@ -12,6 +13,11 @@ are called when the parser discovers the associated structures in the
 document being parsed.  A start tag is an example of the kind of
 structures for which you may register handlers.
 
+Expat supports the following compilers:
+- GNU GCC >=4.5
+- LLVM Clang >=3.5
+- Microsoft Visual Studio >=8.0/2005
+
 Windows users should use the
 [`expat_win32` package](https://sourceforge.net/projects/expat/files/expat_win32/),
 which includes both precompiled libraries and executables, and source code for
@@ -124,3 +130,59 @@ information.
 
 A reference manual is available in the file `doc/reference.html` in this
 distribution.
+
+
+The CMake build system is still *experimental* and will replace the primary
+build system based on GNU Autotools at some point when it is ready.
+For an idea of the available (non-advanced) options for building with CMake:
+
+```console
+# rm -f CMakeCache.txt ; cmake -D_EXPAT_HELP=ON -LH . | grep -B1 ':.*=' | sed 's,^--$,,'
+// Choose the type of build, options are: None Debug Release RelWithDebInfo MinSizeRel ...
+CMAKE_BUILD_TYPE:STRING=
+
+// Install path prefix, prepended onto install directories.
+CMAKE_INSTALL_PREFIX:PATH=/usr/local
+
+// Path to a program.
+DOCBOOK_TO_MAN:FILEPATH=/usr/bin/docbook2x-man
+
+// build man page for xmlwf
+EXPAT_BUILD_DOCS:BOOL=ON
+
+// build the examples for expat library
+EXPAT_BUILD_EXAMPLES:BOOL=ON
+
+// build fuzzers for the expat library
+EXPAT_BUILD_FUZZERS:BOOL=OFF
+
+// build the tests for expat library
+EXPAT_BUILD_TESTS:BOOL=ON
+
+// build the xmlwf tool for expat library
+EXPAT_BUILD_TOOLS:BOOL=ON
+
+// Character type to use (char|ushort|wchar_t) [default=char]
+EXPAT_CHAR_TYPE:STRING=char
+
+// install expat files in cmake install target
+EXPAT_ENABLE_INSTALL:BOOL=ON
+
+// Use /MT flag (static CRT) when compiling in MSVC
+EXPAT_MSVC_STATIC_CRT:BOOL=OFF
+
+// build a shared expat library
+EXPAT_SHARED_LIBS:BOOL=ON
+
+// Treat all compiler warnings as errors
+EXPAT_WARNINGS_AS_ERRORS:BOOL=OFF
+
+// Make use of getrandom function (ON|OFF|AUTO) [default=AUTO]
+EXPAT_WITH_GETRANDOM:STRING=AUTO
+
+// utilize libbsd (for arc4random_buf)
+EXPAT_WITH_LIBBSD:BOOL=OFF
+
+// Make use of syscall SYS_getrandom (ON|OFF|AUTO) [default=AUTO]
+EXPAT_WITH_SYS_GETRANDOM:STRING=AUTO
+```
diff --git a/contrib/expat/configure.ac b/contrib/expat/configure.ac
index a68d9a4e3da2..e2b9a1146286 100644
--- a/contrib/expat/configure.ac
+++ b/contrib/expat/configure.ac
@@ -10,8 +10,8 @@ dnl   under the terms of the License (based on the MIT/X license) contained
 dnl   in the file COPYING that comes with this distribution.
 dnl
 
-dnl Ensure that Expat is configured with autoconf 2.58 or newer
-AC_PREREQ(2.58)
+dnl Ensure that Expat is configured with autoconf 2.69 or newer.
+AC_PREREQ(2.69)
 
 dnl Get the version number of Expat, using m4's esyscmd() command to run
 dnl the command at m4-generation time. This allows us to create an m4
@@ -23,16 +23,18 @@ dnl
 dnl NOTE: esyscmd() is a GNU M4 extension. Thus, we wrap it in an appropriate
 dnl test. I believe this test will work, but I don't have a place with non-
 dnl GNU M4 to test it right now.
-define([expat_version], ifdef([__gnu__],
-                              [esyscmd(conftools/get-version.sh lib/expat.h)],
-                              [2.2.x]))
+m4_define([expat_version],
+  m4_ifdef([__gnu__],
+           [esyscmd(conftools/get-version.sh lib/expat.h)],
+           [2.2.x]))
 AC_INIT(expat, expat_version, expat-bugs@libexpat.org)
-undefine([expat_version])
+m4_undefine([expat_version])
 
-AC_CONFIG_SRCDIR(Makefile.in)
-AC_CONFIG_AUX_DIR(conftools)
-AM_INIT_AUTOMAKE
+AC_CONFIG_SRCDIR([Makefile.in])
+AC_CONFIG_AUX_DIR([conftools])
 AC_CONFIG_MACRO_DIR([m4])
+AC_CANONICAL_HOST
+AM_INIT_AUTOMAKE
 
 
 dnl
@@ -42,165 +44,211 @@ dnl If the API has changed, increment LIBCURRENT and set LIBREVISION to 0
 dnl
 dnl If the API changes compatibly (i.e. simply adding a new function
 dnl without changing or removing earlier interfaces), then increment LIBAGE.
-dnl 
+dnl
 dnl If the API changes incompatibly set LIBAGE back to 0
 dnl
 
-LIBCURRENT=7   # sync
-LIBREVISION=8  # with
-LIBAGE=6       # CMakeLists.txt!
+LIBCURRENT=7    # sync
+LIBREVISION=11  # with
+LIBAGE=6        # CMakeLists.txt!
 
-CPPFLAGS="${CPPFLAGS} -DHAVE_EXPAT_CONFIG_H"
-AC_CONFIG_HEADER(expat_config.h)
+AX_APPEND_FLAG([-DHAVE_EXPAT_CONFIG_H], [CPPFLAGS])
+AC_CONFIG_HEADER([expat_config.h])
 
-sinclude(conftools/ac_c_bigendian_cross.m4)
+AM_PROG_AR
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
 
-AC_LIBTOOL_WIN32_DLL
-AC_PROG_LIBTOOL
+LT_PREREQ([2.4])
+LT_INIT([win32-dll])
 
 AC_SUBST(LIBCURRENT)
 AC_SUBST(LIBREVISION)
 AC_SUBST(LIBAGE)
 
-dnl Checks for programs.
+AC_LANG([C])
 AC_PROG_CC_C99
+AS_IF([test "$GCC" = yes],
+  [AX_APPEND_COMPILE_FLAGS([-Wall -Wextra], [CFLAGS])
+   dnl Be careful about adding the -fexceptions option; some versions of
+   dnl GCC don't support it and it causes extra warnings that are only
+   dnl distracting; avoid.
+   AX_APPEND_COMPILE_FLAGS([-fexceptions], [CFLAGS])
+   AX_APPEND_COMPILE_FLAGS([-fno-strict-aliasing -Wmissing-prototypes -Wstrict-prototypes], [CFLAGS])
+   AX_APPEND_COMPILE_FLAGS([-pedantic -Wduplicated-cond -Wduplicated-branches -Wlogical-op], [CFLAGS])
+   AX_APPEND_COMPILE_FLAGS([-Wrestrict -Wnull-dereference -Wjump-misses-init -Wdouble-promotion], [CFLAGS])
+   AX_APPEND_COMPILE_FLAGS([-Wshadow -Wformat=2 -Wmisleading-indentation], [CFLAGS])])
+
+AC_LANG_PUSH([C++])
 AC_PROG_CXX
-AC_PROG_INSTALL
-
-if test "$GCC" = yes ; then
-    dnl
-    dnl Be careful about adding the -fexceptions option; some versions of
-    dnl GCC don't support it and it causes extra warnings that are only
-    dnl distracting; avoid.
-    dnl
-    OLDCFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wstrict-prototypes"
-    CFLAGS="$OLDCFLAGS -fexceptions"
-    AC_MSG_CHECKING(whether $CC accepts -fexceptions)
-    AC_TRY_LINK( , ,
-                   AC_MSG_RESULT(yes),
-                   AC_MSG_RESULT(no); CFLAGS="$OLDCFLAGS")
-    if test "x$CXXFLAGS" = x ; then
-    CXXFLAGS=`echo "$CFLAGS" | sed 's/ -Wmissing-prototypes -Wstrict-prototypes//'`
-    fi
-
-    CFLAGS="${CFLAGS} -fno-strict-aliasing"
-    CXXFLAGS="${CXXFLAGS} -fno-strict-aliasing"
-    LDFLAGS="${LDFLAGS} -fno-strict-aliasing"
-fi
+AS_IF([test "$GCC" = yes],
+  [AX_APPEND_COMPILE_FLAGS([-Wall -Wextra], [CXXFLAGS])
+   dnl Be careful about adding the -fexceptions option; some versions of
+   dnl GCC don't support it and it causes extra warnings that are only
+   dnl distracting; avoid.
+   AX_APPEND_COMPILE_FLAGS([-fexceptions], [CXXFLAGS])
+   AX_APPEND_COMPILE_FLAGS([-fno-strict-aliasing], [CXXFLAGS])])
+AC_LANG_POP([C++])
+
+AS_IF([test "$GCC" = yes],
+  [AX_APPEND_LINK_FLAGS([-fno-strict-aliasing],[LDFLAGS])])
+
+dnl patching ${archive_cmds} to affect generation of file "libtool" to fix linking with clang (issue #312)
+AS_CASE(["$LD"],[*clang*],
+  [AS_CASE(["${host_os}"],
+     [*linux*],[archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'])])
+
+EXPATCFG_COMPILER_SUPPORTS_VISIBILITY([
+  AX_APPEND_FLAG([-fvisibility=hidden],       [CFLAGS])
+  AX_APPEND_FLAG([-DXML_ENABLE_VISIBILITY=1], [CFLAGS])])
 
 dnl Checks for header files.
 AC_HEADER_STDC
 
 dnl Checks for typedefs, structures, and compiler characteristics.
 
-dnl Note: Avoid using AC_C_BIGENDIAN because it does not
-dnl work in a cross compile.
-AC_C_BIGENDIAN_CROSS
+dnl We define BYTEORDER to 1234 when the platform is little endian; it
+dnl defines it to 4321 when the  platform is big endian.  We also define
+dnl WORDS_BIGENDIAN to 1 when the platform is big endian.
+dnl
+dnl A  long time  ago (early 2000  years) AC_C_BIGENDIAN  was considered
+dnl wrong when cross compiling, now (2018, GNU Autoconf 2.69) we assume
+dnl it is fine.
+AC_C_BIGENDIAN([AC_DEFINE([WORDS_BIGENDIAN], 1)
+                AS_VAR_SET([BYTEORDER], 4321)],
+               [AS_VAR_SET([BYTEORDER], 1234)])
+AC_DEFINE_UNQUOTED([BYTEORDER], $BYTEORDER, [1234 = LILENDIAN, 4321 = BIGENDIAN])
 
 AC_C_CONST
 AC_TYPE_SIZE_T
-AC_CHECK_FUNCS(memmove bcopy)
-
 
-AC_ARG_WITH([xmlwf], [
-AS_HELP_STRING([--without-xmlwf], [do not build xmlwf])], [], [with_xmlwf=yes])
+AC_ARG_WITH([xmlwf],
+  [AS_HELP_STRING([--without-xmlwf], [do not build xmlwf])],
+  [],
+  [with_xmlwf=yes])
 AM_CONDITIONAL([WITH_XMLWF], [test x${with_xmlwf} = xyes])
 
-AM_CONDITIONAL([MINGW], [echo -- "${host}" | ${FGREP} mingw >/dev/null])
+AC_ARG_WITH([examples],
+  [AS_HELP_STRING([--without-examples], [do not build examples @<:@default=included@:>@])],
+  [],
+  [with_examples=yes])
+AM_CONDITIONAL([WITH_EXAMPLES], [test x${with_examples} = xyes])
+
+AC_ARG_WITH([tests],
+  [AS_HELP_STRING([--without-tests], [do not build tests @<:@default=included@:>@])],
+  [],
+  [with_tests=yes])
+AM_CONDITIONAL([WITH_TESTS], [test x${with_tests} = xyes])
+
+
+AS_VAR_SET([EXPATCFG_ON_MINGW],[no])
+AS_CASE("${host_os}",
+  [mingw*],
+  [AS_VAR_SET([EXPATCFG_ON_MINGW],[yes])
+   AC_MSG_NOTICE([detected OS: MinGW])])
+AM_CONDITIONAL([MINGW], [test x${EXPATCFG_ON_MINGW} = xyes])
+
 AM_CONDITIONAL([UNICODE], [echo -- "${CPPFLAGS}${CFLAGS}" | ${FGREP} XML_UNICODE >/dev/null])
 
 
-AC_ARG_WITH([libbsd], [
-AS_HELP_STRING([--with-libbsd], [utilize libbsd (for arc4random_buf)])
-], [], [with_libbsd=no])
-AS_IF([test "x${with_libbsd}" != xno], [
-  AC_CHECK_LIB([bsd], [arc4random_buf], [], [
-    AS_IF([test "x${with_libbsd}" = xyes], [
-      AC_MSG_ERROR([Enforced use of libbsd cannot be satisfied.])
-    ])
-  ])
-])
+AC_ARG_WITH([libbsd],
+  [AS_HELP_STRING([--with-libbsd], [utilize libbsd (for arc4random_buf)])],
+  [],
+  [with_libbsd=no])
+AS_IF([test "x${with_libbsd}" != xno],
+  [AC_CHECK_LIB([bsd],
+     [arc4random_buf],
+     [],
+     [AS_IF([test "x${with_libbsd}" = xyes],
+        [AC_MSG_ERROR([Enforced use of libbsd cannot be satisfied.])])])])
 AC_MSG_CHECKING([for arc4random_buf (BSD or libbsd)])
 AC_LINK_IFELSE([AC_LANG_SOURCE([
-  #include <stdlib.h>  /* for arc4random_buf on BSD, for NULL */
-  #if defined(HAVE_LIBBSD)
-  # include <bsd/stdlib.h>
-  #endif
-  int main() {
-    arc4random_buf(NULL, 0U);
-    return 0;
-  }
-])], [
-    AC_DEFINE([HAVE_ARC4RANDOM_BUF], [1],
-        [Define to 1 if you have the `arc4random_buf' function.])
-    AC_MSG_RESULT([yes])
-], [
-    AC_MSG_RESULT([no])
-
-    AC_MSG_CHECKING([for arc4random (BSD, macOS or libbsd)])
-    AC_LINK_IFELSE([AC_LANG_SOURCE([
-      #if defined(HAVE_LIBBSD)
-      # include <bsd/stdlib.h>
-      #else
-      # include <stdlib.h>
-      #endif
-      int main() {
+    #include <stdlib.h>  /* for arc4random_buf on BSD, for NULL */
+    #if defined(HAVE_LIBBSD)
+    # include <bsd/stdlib.h>
+    #endif
+    int main() {
+      arc4random_buf(NULL, 0U);
+      return 0;
+    }
+  ])],
+  [AC_DEFINE([HAVE_ARC4RANDOM_BUF], [1], [Define to 1 if you have the `arc4random_buf' function.])
+   AC_MSG_RESULT([yes])],
+  [AC_MSG_RESULT([no])
+
+   AC_MSG_CHECKING([for arc4random (BSD, macOS or libbsd)])
+   AC_LINK_IFELSE([AC_LANG_SOURCE([
+       #if defined(HAVE_LIBBSD)
+       # include <bsd/stdlib.h>
+       #else
+       # include <stdlib.h>
+       #endif
+       int main() {
           arc4random();
           return 0;
-      }
-    ])], [
-        AC_DEFINE([HAVE_ARC4RANDOM], [1],
-            [Define to 1 if you have the `arc4random' function.])
-        AC_MSG_RESULT([yes])
-    ], [
-        AC_MSG_RESULT([no])
-    ])
-])
-
-
-AC_MSG_CHECKING([for getrandom (Linux 3.17+, glibc 2.25+)])
-AC_LINK_IFELSE([AC_LANG_SOURCE([
-  #include <stdlib.h>  /* for NULL */
-  #include <sys/random.h>
-  int main() {
-    return getrandom(NULL, 0U, 0U);
-  }
-])], [
-    AC_DEFINE([HAVE_GETRANDOM], [1],
-        [Define to 1 if you have the `getrandom' function.])
-    AC_MSG_RESULT([yes])
-], [
-    AC_MSG_RESULT([no])
-
-    AC_MSG_CHECKING([for syscall SYS_getrandom (Linux 3.17+)])
-    AC_LINK_IFELSE([AC_LANG_SOURCE([
-      #include <stdlib.h>  /* for NULL */
-      #include <unistd.h>  /* for syscall */
-      #include <sys/syscall.h>  /* for SYS_getrandom */
-      int main() {
-        syscall(SYS_getrandom, NULL, 0, 0);
-        return 0;
-      }
-    ])], [
-        AC_DEFINE([HAVE_SYSCALL_GETRANDOM], [1],
-            [Define to 1 if you have `syscall' and `SYS_getrandom'.])
-        AC_MSG_RESULT([yes])
-    ], [
-        AC_MSG_RESULT([no])
-    ])
-])
-
+       }
+     ])],
+     [AC_DEFINE([HAVE_ARC4RANDOM], [1], [Define to 1 if you have the `arc4random' function.])
+      AC_MSG_RESULT([yes])],
+     [AC_MSG_RESULT([no])])])
+
+AC_ARG_WITH([getrandom],
+  [AS_HELP_STRING([--with-getrandom],
+                  [enforce the use of getrandom function in the system @<:@default=check@:>@])
+AS_HELP_STRING([--without-getrandom],
+               [skip auto detect of getrandom @<:@default=check@:>@])],
+  [],
+  [with_getrandom=check])
+
+AS_IF([test "x$with_getrandom" != xno],
+  [AC_MSG_CHECKING([for getrandom (Linux 3.17+, glibc 2.25+)])
+   AC_LINK_IFELSE([AC_LANG_SOURCE([
+       #include <stdlib.h>  /* for NULL */
+       #include <sys/random.h>
+       int main() {
+         return getrandom(NULL, 0U, 0U);
+       }
+     ])],
+     [AC_DEFINE([HAVE_GETRANDOM], [1], [Define to 1 if you have the `getrandom' function.])
+      AC_MSG_RESULT([yes])],
+     [AC_MSG_RESULT([no])
+      AS_IF([test "x$with_getrandom" = xyes],
+        [AC_MSG_ERROR([enforced the use of getrandom --with-getrandom, but not detected])])])])
+
+AC_ARG_WITH([sys_getrandom],
+  [AS_HELP_STRING([--with-sys-getrandom],
+                  [enforce the use of syscall SYS_getrandom function in the system @<:@default=check@:>@])
+AS_HELP_STRING([--without-sys-getrandom],
+               [skip auto detect of syscall SYS_getrandom @<:@default=check@:>@])],
+  [],
+  [with_sys_getrandom=check])
+
+AS_IF([test "x$with_sys_getrandom" != xno],
+  [AC_MSG_CHECKING([for syscall SYS_getrandom (Linux 3.17+)])
+   AC_LINK_IFELSE([AC_LANG_SOURCE([
+       #include <stdlib.h>  /* for NULL */
+       #include <unistd.h>  /* for syscall */
+       #include <sys/syscall.h>  /* for SYS_getrandom */
+       int main() {
+         syscall(SYS_getrandom, NULL, 0, 0);
+         return 0;
+     }
+   ])],
+     [AC_DEFINE([HAVE_SYSCALL_GETRANDOM], [1], [Define to 1 if you have `syscall' and `SYS_getrandom'.])
+      AC_MSG_RESULT([yes])],
+     [AC_MSG_RESULT([no])
+      AS_IF([test "x$with_sys_getrandom" = xyes],
+        [AC_MSG_ERROR([enforced the use of syscall SYS_getrandom --with-sys-getrandom, but not detected])])])])
 
 dnl Only needed for xmlwf:
 AC_CHECK_HEADERS(fcntl.h unistd.h)
 AC_TYPE_OFF_T
 AC_FUNC_MMAP
 
-if test "$ac_cv_func_mmap_fixed_mapped" = "yes"; then
-    FILEMAP=unixfilemap
-else
-    FILEMAP=readfilemap
-fi
+AS_IF([test "$ac_cv_func_mmap_fixed_mapped" = "yes"],
+  [AS_VAR_SET(FILEMAP,unixfilemap)],
+  [AS_VAR_SET(FILEMAP,readfilemap)])
 AC_SUBST(FILEMAP)
 
 
@@ -212,26 +260,34 @@ AC_DEFINE([XML_DTD], 1,
 AC_DEFINE([XML_DEV_URANDOM], 1,
           [Define to include code reading entropy from `/dev/urandom'.])
 
+AC_ARG_ENABLE([xml-attr-info],
+  [AS_HELP_STRING([--enable-xml-attr-info],
+     [Enable retrieving the byte offsets for attribute names and values @<:@default=no@:>@])],
+  [],
+  [enable_xml_attr_info=no])
+AS_IF([test "x${enable_xml_attr_info}" = "xyes"],
+      [AC_DEFINE([XML_ATTR_INFO], 1,
+         [Define to allow retrieving the byte offsets for attribute names and values.])])
+
 AC_ARG_ENABLE([xml-context],
   AS_HELP_STRING([--enable-xml-context @<:@COUNT@:>@],
     [Retain context around the current parse point;
-        default is enabled and a size of 1024 bytes])
+     default is enabled and a size of 1024 bytes])
 AS_HELP_STRING([--disable-xml-context],
     [Do not retain context around the current parse point]),
-  [enable_xml_context=${enableval}])
-AS_IF([test "x${enable_xml_context}" != "xno"], [
-  AS_IF([test "x${enable_xml_context}" = "xyes" \
-      -o "x${enable_xml_context}" = "x"], [
-    enable_xml_context=1024
-  ])
-  AC_DEFINE_UNQUOTED([XML_CONTEXT_BYTES], [${enable_xml_context}],
-    [Define to specify how much context to retain around the current parse point.])
-])
-
-AC_ARG_WITH([docbook], [AS_HELP_STRING([--with-docbook],
-    [enforce XML to man page compilation @<:@default=check@:>@])
+    [enable_xml_context=${enableval}])
+AS_IF([test "x${enable_xml_context}" != "xno"],
+  [AS_IF([test "x${enable_xml_context}" = "xyes" \
+            -o "x${enable_xml_context}" = "x"],
+     [AS_VAR_SET(enable_xml_context,1024)])
+   AC_DEFINE_UNQUOTED([XML_CONTEXT_BYTES], [${enable_xml_context}],
+     [Define to specify how much context to retain around the current parse point.])])
+
+AC_ARG_WITH([docbook],
+  [AS_HELP_STRING([--with-docbook],
+                  [enforce XML to man page compilation @<:@default=check@:>@])
 AS_HELP_STRING([--without-docbook],
-    [skip XML to man page compilation @<:@default=check@:>@])],
+               [skip XML to man page compilation @<:@default=check@:>@])],
   [],
   [with_docbook=check])
 
@@ -251,14 +307,13 @@ AS_IF([test "x${DOCBOOK_TO_MAN}" != x -a "x$with_docbook" != xno],
 
 AM_CONDITIONAL(WITH_DOCBOOK, [test "x${DOCBOOK_TO_MAN}" != x])
 
-AC_CONFIG_FILES([Makefile expat.pc])
-AC_CONFIG_FILES([
-  doc/Makefile
-  examples/Makefile
-  lib/Makefile
-  tests/Makefile
-  tests/benchmark/Makefile
-  xmlwf/Makefile
-])
+AC_CONFIG_FILES([Makefile]
+  [expat.pc]
+  [doc/Makefile]
+  [examples/Makefile]
+  [lib/Makefile]
+  [tests/Makefile]
+  [tests/benchmark/Makefile]
+  [xmlwf/Makefile])
 AC_CONFIG_FILES([run.sh], [chmod +x run.sh])
 AC_OUTPUT
diff --git a/contrib/expat/doc/Makefile.am b/contrib/expat/doc/Makefile.am
index d8a35c0da235..e2f029837a41 100644
--- a/contrib/expat/doc/Makefile.am
+++ b/contrib/expat/doc/Makefile.am
@@ -28,14 +28,17 @@
 # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 # USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+.PHONY: dist-hook  # not inside conditional to avoid automake warning
+
+if WITH_DOCBOOK
 dist_man_MANS = xmlwf.1
 
 xmlwf.1: xmlwf.xml
-if WITH_DOCBOOK
 	-rm -f $@
 	$(DOCBOOK_TO_MAN) $<
 	test -f $@ || mv XMLWF.1 $@
 else
+dist-hook:
 	@echo 'ERROR: Configure with --with-docbook for "make dist".' 1>&2
 	@false
 endif
diff --git a/contrib/expat/doc/Makefile.in b/contrib/expat/doc/Makefile.in
index 6a206e84add9..e021e8c675fe 100644
--- a/contrib/expat/doc/Makefile.in
+++ b/contrib/expat/doc/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -122,7 +122,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -310,7 +317,7 @@ target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
-dist_man_MANS = xmlwf.1
+@WITH_DOCBOOK_TRUE@dist_man_MANS = xmlwf.1
 EXTRA_DIST = \
     expat.png \
     reference.html \
@@ -338,8 +345,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -405,8 +412,12 @@ ctags CTAGS:
 
 cscope cscopelist:
 
+@WITH_DOCBOOK_TRUE@dist-hook:
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -436,6 +447,9 @@ distdir: $(DISTFILES)
 	    || exit 1; \
 	  fi; \
 	done
+	$(MAKE) $(AM_MAKEFLAGS) \
+	  top_distdir="$(top_distdir)" distdir="$(distdir)" \
+	  dist-hook
 check-am: all-am
 check: check-am
 all-am: Makefile $(MANS)
@@ -544,25 +558,28 @@ uninstall-man: uninstall-man1
 .MAKE: install-am install-strip
 
 .PHONY: all all-am check check-am clean clean-generic clean-libtool \
-	clean-local cscopelist-am ctags-am distclean distclean-generic \
-	distclean-libtool distdir dvi dvi-am html html-am info info-am \
-	install install-am install-data install-data-am install-dvi \
-	install-dvi-am install-exec install-exec-am install-html \
-	install-html-am install-info install-info-am install-man \
-	install-man1 install-pdf install-pdf-am install-ps \
-	install-ps-am install-strip installcheck installcheck-am \
-	installdirs maintainer-clean maintainer-clean-generic \
-	mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
-	ps ps-am tags-am uninstall uninstall-am uninstall-man \
-	uninstall-man1
+	clean-local cscopelist-am ctags-am dist-hook distclean \
+	distclean-generic distclean-libtool distdir dvi dvi-am html \
+	html-am info info-am install install-am install-data \
+	install-data-am install-dvi install-dvi-am install-exec \
+	install-exec-am install-html install-html-am install-info \
+	install-info-am install-man install-man1 install-pdf \
+	install-pdf-am install-ps install-ps-am install-strip \
+	installcheck installcheck-am installdirs maintainer-clean \
+	maintainer-clean-generic mostlyclean mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am tags-am uninstall \
+	uninstall-am uninstall-man uninstall-man1
 
 .PRECIOUS: Makefile
 
 
-xmlwf.1: xmlwf.xml
+.PHONY: dist-hook  # not inside conditional to avoid automake warning
+
+@WITH_DOCBOOK_TRUE@xmlwf.1: xmlwf.xml
 @WITH_DOCBOOK_TRUE@	-rm -f $@
 @WITH_DOCBOOK_TRUE@	$(DOCBOOK_TO_MAN) $<
 @WITH_DOCBOOK_TRUE@	test -f $@ || mv XMLWF.1 $@
+@WITH_DOCBOOK_FALSE@dist-hook:
 @WITH_DOCBOOK_FALSE@	@echo 'ERROR: Configure with --with-docbook for "make dist".' 1>&2
 @WITH_DOCBOOK_FALSE@	@false
 
diff --git a/contrib/expat/doc/reference.html b/contrib/expat/doc/reference.html
index efc19f485f1e..23e9a979707b 100644
--- a/contrib/expat/doc/reference.html
+++ b/contrib/expat/doc/reference.html
@@ -276,9 +276,11 @@ directions or Unix directions below.</p>
 
 <p>If you're using the GNU compiler under cygwin, follow the Unix
 directions in the next section. Otherwise if you have Microsoft's
-Developer Studio installed, then from Windows Explorer double-click on
-"expat.vcxproj" in the lib directory and build and install in the usual
-manner.</p>
+Developer Studio installed,
+you can use CMake to generate a <code>.sln</code> file, e.g.
+<code>
+cmake -G"Visual Studio 15 2017" -DCMAKE_BUILD_TYPE=RelWithDebInfo .
+</code>, and build Expat using <code>msbuild /m expat.sln</code> after.</p>
 
 <p>Alternatively, you may download the Win32 binary package that
 contains the "expat.h" include file and a pre-built DLL.</p>
@@ -2152,7 +2154,7 @@ function behavior. In order to have an effect this must be called
 before parsing has started. Returns 1 if successful, 0 when called
 after <code>XML_Parse</code> or <code>XML_ParseBuffer</code>.
 <p><b>Note:</b>This call is optional, as the parser will auto-generate 
-a new random salt value if no value has been set at the start of parsing.
+a new random salt value if no value has been set at the start of parsing.</p>
 <p><b>Note:</b>One should not call <code>XML_SetHashSalt</code> with a
 hash salt value of 0, as this value is used as sentinel value to indicate
 that <code>XML_SetHashSalt</code> has <b>not</b> been called. Consequently
diff --git a/contrib/expat/examples/Makefile.in b/contrib/expat/examples/Makefile.in
index d995eae88c8a..391c71ee93e2 100644
--- a/contrib/expat/examples/Makefile.in
+++ b/contrib/expat/examples/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -124,7 +124,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -158,7 +165,8 @@ am__v_at_0 = @
 am__v_at_1 = 
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/conftools/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/elements.Po ./$(DEPDIR)/outline.Po
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -359,8 +367,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -395,8 +403,14 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elements.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/outline.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/elements.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/outline.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@@ -477,7 +491,10 @@ cscopelist-am: $(am__tagged_files)
 distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -547,7 +564,8 @@ clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
 	mostlyclean-am
 
 distclean: distclean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/elements.Po
+	-rm -f ./$(DEPDIR)/outline.Po
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -593,7 +611,8 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/elements.Po
+	-rm -f ./$(DEPDIR)/outline.Po
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -614,9 +633,9 @@ uninstall-am:
 
 .MAKE: install-am install-strip
 
-.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
-	clean-libtool clean-noinstPROGRAMS cscopelist-am ctags \
-	ctags-am distclean distclean-compile distclean-generic \
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
+	clean-generic clean-libtool clean-noinstPROGRAMS cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
 	distclean-libtool distclean-tags distdir dvi dvi-am html \
 	html-am info info-am install install-am install-data \
 	install-data-am install-dvi install-dvi-am install-exec \
diff --git a/contrib/expat/examples/elements.c b/contrib/expat/examples/elements.c
index 9d2027e449c7..eb0c729bff15 100644
--- a/contrib/expat/examples/elements.c
+++ b/contrib/expat/examples/elements.c
@@ -38,25 +38,20 @@
 #include <expat.h>
 
 #ifdef XML_LARGE_SIZE
-# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
-#  define XML_FMT_INT_MOD "I64"
-# else
 #  define XML_FMT_INT_MOD "ll"
-# endif
 #else
-# define XML_FMT_INT_MOD "l"
+#  define XML_FMT_INT_MOD "l"
 #endif
 
 #ifdef XML_UNICODE_WCHAR_T
-# include <wchar.h>
-# define XML_FMT_STR "ls"
+#  include <wchar.h>
+#  define XML_FMT_STR "ls"
 #else
-# define XML_FMT_STR "s"
+#  define XML_FMT_STR "s"
 #endif
 
 static void XMLCALL
-startElement(void *userData, const XML_Char *name, const XML_Char **atts)
-{
+startElement(void *userData, const XML_Char *name, const XML_Char **atts) {
   int i;
   int *depthPtr = (int *)userData;
   (void)atts;
@@ -68,8 +63,7 @@ startElement(void *userData, const XML_Char *name, const XML_Char **atts)
 }
 
 static void XMLCALL
-endElement(void *userData, const XML_Char *name)
-{
+endElement(void *userData, const XML_Char *name) {
   int *depthPtr = (int *)userData;
   (void)name;
 
@@ -77,8 +71,7 @@ endElement(void *userData, const XML_Char *name)
 }
 
 int
-main(int argc, char *argv[])
-{
+main(int argc, char *argv[]) {
   char buf[BUFSIZ];
   XML_Parser parser = XML_ParserCreate(NULL);
   int done;
@@ -92,13 +85,13 @@ main(int argc, char *argv[])
     size_t len = fread(buf, 1, sizeof(buf), stdin);
     done = len < sizeof(buf);
     if (XML_Parse(parser, buf, (int)len, done) == XML_STATUS_ERROR) {
-      fprintf(stderr,
-              "%" XML_FMT_STR " at line %" XML_FMT_INT_MOD "u\n",
+      fprintf(stderr, "%" XML_FMT_STR " at line %" XML_FMT_INT_MOD "u\n",
               XML_ErrorString(XML_GetErrorCode(parser)),
               XML_GetCurrentLineNumber(parser));
+      XML_ParserFree(parser);
       return 1;
     }
-  } while (!done);
+  } while (! done);
   XML_ParserFree(parser);
   return 0;
 }
diff --git a/contrib/expat/examples/outline.c b/contrib/expat/examples/outline.c
index 3e0bbaa498c8..d996b8e3a8d3 100644
--- a/contrib/expat/examples/outline.c
+++ b/contrib/expat/examples/outline.c
@@ -36,30 +36,25 @@
 #include <expat.h>
 
 #ifdef XML_LARGE_SIZE
-# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
-#  define XML_FMT_INT_MOD "I64"
-# else
 #  define XML_FMT_INT_MOD "ll"
-# endif
 #else
-# define XML_FMT_INT_MOD "l"
+#  define XML_FMT_INT_MOD "l"
 #endif
 
 #ifdef XML_UNICODE_WCHAR_T
-# define XML_FMT_STR "ls"
+#  define XML_FMT_STR "ls"
 #else
-# define XML_FMT_STR "s"
+#  define XML_FMT_STR "s"
 #endif
 
-#define BUFFSIZE        8192
+#define BUFFSIZE 8192
 
 char Buff[BUFFSIZE];
 
 int Depth;
 
 static void XMLCALL
-start(void *data, const XML_Char *el, const XML_Char **attr)
-{
+start(void *data, const XML_Char *el, const XML_Char **attr) {
   int i;
   (void)data;
 
@@ -77,8 +72,7 @@ start(void *data, const XML_Char *el, const XML_Char **attr)
 }
 
 static void XMLCALL
-end(void *data, const XML_Char *el)
-{
+end(void *data, const XML_Char *el) {
   (void)data;
   (void)el;
 
@@ -86,8 +80,7 @@ end(void *data, const XML_Char *el)
 }
 
 int
-main(int argc, char *argv[])
-{
+main(int argc, char *argv[]) {
   XML_Parser p = XML_ParserCreate(NULL);
   (void)argc;
   (void)argv;
diff --git a/contrib/expat/expat_config.h.in b/contrib/expat/expat_config.h.in
index 63c0d03eb83d..59207b42e41d 100644
--- a/contrib/expat/expat_config.h.in
+++ b/contrib/expat/expat_config.h.in
@@ -1,6 +1,9 @@
 /* expat_config.h.in.  Generated from configure.ac by autoheader.  */
 
-/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
+/* Define if building universal (internal helper macro) */
+#undef AC_APPLE_UNIVERSAL_BUILD
+
+/* 1234 = LILENDIAN, 4321 = BIGENDIAN */
 #undef BYTEORDER
 
 /* Define to 1 if you have the `arc4random' function. */
@@ -9,9 +12,6 @@
 /* Define to 1 if you have the `arc4random_buf' function. */
 #undef HAVE_ARC4RANDOM_BUF
 
-/* Define to 1 if you have the `bcopy' function. */
-#undef HAVE_BCOPY
-
 /* Define to 1 if you have the <dlfcn.h> header file. */
 #undef HAVE_DLFCN_H
 
@@ -30,9 +30,6 @@
 /* Define to 1 if you have the `bsd' library (-lbsd). */
 #undef HAVE_LIBBSD
 
-/* Define to 1 if you have the `memmove' function. */
-#undef HAVE_MEMMOVE
-
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
@@ -96,8 +93,21 @@
 /* Version number of package */
 #undef VERSION
 
-/* whether byteorder is bigendian */
-#undef WORDS_BIGENDIAN
+/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most
+   significant byte first (like Motorola and SPARC, unlike Intel). */
+#if defined AC_APPLE_UNIVERSAL_BUILD
+# if defined __BIG_ENDIAN__
+#  define WORDS_BIGENDIAN 1
+# endif
+#else
+# ifndef WORDS_BIGENDIAN
+#  undef WORDS_BIGENDIAN
+# endif
+#endif
+
+/* Define to allow retrieving the byte offsets for attribute names and values.
+   */
+#undef XML_ATTR_INFO
 
 /* Define to specify how much context to retain around the current parse
    point. */
diff --git a/contrib/expat/fix-xmltest-log.sh b/contrib/expat/fix-xmltest-log.sh
new file mode 100755
index 000000000000..c143e93cf20a
--- /dev/null
+++ b/contrib/expat/fix-xmltest-log.sh
@@ -0,0 +1,48 @@
+#! /usr/bin/env bash
+#                          __  __            _
+#                       ___\ \/ /_ __   __ _| |_
+#                      / _ \\  /| '_ \ / _` | __|
+#                     |  __//  \| |_) | (_| | |_
+#                      \___/_/\_\ .__/ \__,_|\__|
+#                               |_| XML parser
+#
+# Copyright (c) 2019 Expat development team
+# Licensed under the MIT license:
+#
+# 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  furnished 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, FITNESS 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.
+
+set -e
+
+filename="${1:-tests/xmltest.log}"
+
+dos2unix "${filename}"
+
+tempfile="$(mktemp)"
+sed \
+        -e 's/^wine: Call .* msvcrt\.dll\._wperror, aborting$/ibm49i02.dtd: No such file or directory/' \
+        \
+        -e '/^wine: /d' \
+        -e '/^Application tried to create a window, but no driver could be loaded.$/d' \
+        -e '/^Make sure that your X server is running and that $DISPLAY is set correctly.$/d' \
+        -e '/^err:systray:initialize_systray Could not create tray window$/d' \
+        -e '/^In ibm\/invalid\/P49\/: Unhandled exception: unimplemented .\+/d' \
+        \
+        "${filename}" > "${tempfile}"
+mv "${tempfile}" "${filename}"
diff --git a/contrib/expat/lib/Makefile.am b/contrib/expat/lib/Makefile.am
index 534369e8af20..8cb451ed4647 100644
--- a/contrib/expat/lib/Makefile.am
+++ b/contrib/expat/lib/Makefile.am
@@ -40,7 +40,6 @@ libexpat_la_LDFLAGS = \
     -version-info @LIBCURRENT@:@LIBREVISION@:@LIBAGE@
 
 libexpat_la_SOURCES = \
-    loadlibrary.c \
     xmlparse.c \
     xmltok.c \
     xmlrole.c
diff --git a/contrib/expat/lib/Makefile.in b/contrib/expat/lib/Makefile.in
index 91b27b3da63f..bbd6a1885fc8 100644
--- a/contrib/expat/lib/Makefile.in
+++ b/contrib/expat/lib/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -125,7 +125,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -166,8 +173,7 @@ am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(docdir)" \
 	"$(DESTDIR)$(includedir)"
 LTLIBRARIES = $(lib_LTLIBRARIES)
 libexpat_la_LIBADD =
-am_libexpat_la_OBJECTS = loadlibrary.lo xmlparse.lo xmltok.lo \
-	xmlrole.lo
+am_libexpat_la_OBJECTS = xmlparse.lo xmltok.lo xmlrole.lo
 libexpat_la_OBJECTS = $(am_libexpat_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -190,7 +196,9 @@ am__v_at_0 = @
 am__v_at_1 = 
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/conftools/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/xmlparse.Plo ./$(DEPDIR)/xmlrole.Plo \
+	./$(DEPDIR)/xmltok.Plo
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -378,7 +386,6 @@ libexpat_la_LDFLAGS = \
     -version-info @LIBCURRENT@:@LIBREVISION@:@LIBAGE@
 
 libexpat_la_SOURCES = \
-    loadlibrary.c \
     xmlparse.c \
     xmltok.c \
     xmlrole.c
@@ -428,8 +435,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -485,10 +492,15 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/loadlibrary.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlparse.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlrole.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmltok.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlparse.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlrole.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmltok.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@@ -611,7 +623,10 @@ cscopelist-am: $(am__tagged_files)
 distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -684,7 +699,9 @@ clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
 	mostlyclean-am
 
 distclean: distclean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/xmlparse.Plo
+	-rm -f ./$(DEPDIR)/xmlrole.Plo
+	-rm -f ./$(DEPDIR)/xmltok.Plo
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -731,7 +748,9 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/xmlparse.Plo
+	-rm -f ./$(DEPDIR)/xmlrole.Plo
+	-rm -f ./$(DEPDIR)/xmltok.Plo
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -753,9 +772,9 @@ uninstall-am: uninstall-docDATA uninstall-includeHEADERS \
 
 .MAKE: install-am install-data-am install-strip
 
-.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
-	clean-libLTLIBRARIES clean-libtool cscopelist-am ctags \
-	ctags-am distclean distclean-compile distclean-generic \
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
+	clean-generic clean-libLTLIBRARIES clean-libtool cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
 	distclean-libtool distclean-tags distdir dvi dvi-am html \
 	html-am info info-am install install-am install-data \
 	install-data-am install-data-hook install-docDATA install-dvi \
diff --git a/contrib/expat/lib/asciitab.h b/contrib/expat/lib/asciitab.h
index 2f59fd929065..63b1d1b4482e 100644
--- a/contrib/expat/lib/asciitab.h
+++ b/contrib/expat/lib/asciitab.h
@@ -31,34 +31,34 @@
 */
 
 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
-/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+    /* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
diff --git a/contrib/expat/lib/expat.h b/contrib/expat/lib/expat.h
index 174c3fafda3f..48a6e2a32917 100644
--- a/contrib/expat/lib/expat.h
+++ b/contrib/expat/lib/expat.h
@@ -33,15 +33,6 @@
 #ifndef Expat_INCLUDED
 #define Expat_INCLUDED 1
 
-#ifdef __VMS
-/*      0        1         2         3      0        1         2         3
-        1234567890123456789012345678901     1234567890123456789012345678901 */
-#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler
-#define XML_SetUnparsedEntityDeclHandler    XML_SetUnparsedEntDeclHandler
-#define XML_SetStartNamespaceDeclHandler    XML_SetStartNamespcDeclHandler
-#define XML_SetExternalEntityRefHandlerArg  XML_SetExternalEntRefHandlerArg
-#endif
-
 #include <stdlib.h>
 #include "expat_external.h"
 
@@ -53,8 +44,8 @@ struct XML_ParserStruct;
 typedef struct XML_ParserStruct *XML_Parser;
 
 typedef unsigned char XML_Bool;
-#define XML_TRUE   ((XML_Bool) 1)
-#define XML_FALSE  ((XML_Bool) 0)
+#define XML_TRUE ((XML_Bool)1)
+#define XML_FALSE ((XML_Bool)0)
 
 /* The XML_Status enum gives the possible return values for several
    API functions.  The preprocessor #defines are included so this
@@ -164,25 +155,23 @@ enum XML_Content_Quant {
 typedef struct XML_cp XML_Content;
 
 struct XML_cp {
-  enum XML_Content_Type         type;
-  enum XML_Content_Quant        quant;
-  XML_Char *                    name;
-  unsigned int                  numchildren;
-  XML_Content *                 children;
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  XML_Char *name;
+  unsigned int numchildren;
+  XML_Content *children;
 };
 
-
 /* This is called for an element declaration. See above for
    description of the model argument. It's the caller's responsibility
    to free model when finished with it.
 */
-typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
-                                                const XML_Char *name,
-                                                XML_Content *model);
+typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData,
+                                              const XML_Char *name,
+                                              XML_Content *model);
 
 XMLPARSEAPI(void)
-XML_SetElementDeclHandler(XML_Parser parser,
-                          XML_ElementDeclHandler eldecl);
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
 
 /* The Attlist declaration handler is called for *each* attribute. So
    a single Attlist declaration with multiple attributes declared will
@@ -192,17 +181,12 @@ XML_SetElementDeclHandler(XML_Parser parser,
    value will be NULL in the case of "#REQUIRED". If "isrequired" is
    true and default is non-NULL, then this is a "#FIXED" default.
 */
-typedef void (XMLCALL *XML_AttlistDeclHandler) (
-                                    void            *userData,
-                                    const XML_Char  *elname,
-                                    const XML_Char  *attname,
-                                    const XML_Char  *att_type,
-                                    const XML_Char  *dflt,
-                                    int              isrequired);
+typedef void(XMLCALL *XML_AttlistDeclHandler)(
+    void *userData, const XML_Char *elname, const XML_Char *attname,
+    const XML_Char *att_type, const XML_Char *dflt, int isrequired);
 
 XMLPARSEAPI(void)
-XML_SetAttlistDeclHandler(XML_Parser parser,
-                          XML_AttlistDeclHandler attdecl);
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
 
 /* The XML declaration handler is called for *both* XML declarations
    and text declarations. The way to distinguish is that the version
@@ -212,15 +196,13 @@ XML_SetAttlistDeclHandler(XML_Parser parser,
    was no standalone parameter in the declaration, that it was given
    as no, or that it was given as yes.
 */
-typedef void (XMLCALL *XML_XmlDeclHandler) (void           *userData,
-                                            const XML_Char *version,
-                                            const XML_Char *encoding,
-                                            int             standalone);
+typedef void(XMLCALL *XML_XmlDeclHandler)(void *userData,
+                                          const XML_Char *version,
+                                          const XML_Char *encoding,
+                                          int standalone);
 
 XMLPARSEAPI(void)
-XML_SetXmlDeclHandler(XML_Parser parser,
-                      XML_XmlDeclHandler xmldecl);
-
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
 
 typedef struct {
   void *(*malloc_fcn)(size_t size);
@@ -248,7 +230,6 @@ XML_ParserCreate(const XML_Char *encoding);
 XMLPARSEAPI(XML_Parser)
 XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
 
-
 /* Constructs a new parser using the memory management suite referred to
    by memsuite. If memsuite is NULL, then use the standard library memory
    suite. If namespaceSeparator is non-NULL it creates a parser with
@@ -278,31 +259,27 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
 /* atts is array of name/value pairs, terminated by 0;
    names and values are 0 terminated.
 */
-typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
-                                                 const XML_Char *name,
-                                                 const XML_Char **atts);
-
-typedef void (XMLCALL *XML_EndElementHandler) (void *userData,
-                                               const XML_Char *name);
+typedef void(XMLCALL *XML_StartElementHandler)(void *userData,
+                                               const XML_Char *name,
+                                               const XML_Char **atts);
 
+typedef void(XMLCALL *XML_EndElementHandler)(void *userData,
+                                             const XML_Char *name);
 
 /* s is not 0 terminated. */
-typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,
-                                                  const XML_Char *s,
-                                                  int len);
+typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData,
+                                                const XML_Char *s, int len);
 
 /* target and data are 0 terminated */
-typedef void (XMLCALL *XML_ProcessingInstructionHandler) (
-                                                void *userData,
-                                                const XML_Char *target,
-                                                const XML_Char *data);
+typedef void(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
+                                                        const XML_Char *target,
+                                                        const XML_Char *data);
 
 /* data is 0 terminated */
-typedef void (XMLCALL *XML_CommentHandler) (void *userData,
-                                            const XML_Char *data);
+typedef void(XMLCALL *XML_CommentHandler)(void *userData, const XML_Char *data);
 
-typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);
-typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
+typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData);
+typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
 
 /* This is called for any characters in the XML document for which
    there is no applicable handler.  This includes both characters that
@@ -317,25 +294,23 @@ typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
    default handler: for example, a comment might be split between
    multiple calls.
 */
-typedef void (XMLCALL *XML_DefaultHandler) (void *userData,
-                                            const XML_Char *s,
-                                            int len);
+typedef void(XMLCALL *XML_DefaultHandler)(void *userData, const XML_Char *s,
+                                          int len);
 
 /* This is called for the start of the DOCTYPE declaration, before
    any DTD or internal subset is parsed.
 */
-typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (
-                                            void *userData,
-                                            const XML_Char *doctypeName,
-                                            const XML_Char *sysid,
-                                            const XML_Char *pubid,
-                                            int has_internal_subset);
+typedef void(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,
+                                                   const XML_Char *doctypeName,
+                                                   const XML_Char *sysid,
+                                                   const XML_Char *pubid,
+                                                   int has_internal_subset);
 
 /* This is called for the start of the DOCTYPE declaration when the
    closing > is encountered, but after processing any external
    subset.
 */
-typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
+typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
 
 /* This is called for entity declarations. The is_parameter_entity
    argument will be non-zero if the entity is a parameter entity, zero
@@ -355,20 +330,14 @@ typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
    Note that is_parameter_entity can't be changed to XML_Bool, since
    that would break binary compatibility.
 */
-typedef void (XMLCALL *XML_EntityDeclHandler) (
-                              void *userData,
-                              const XML_Char *entityName,
-                              int is_parameter_entity,
-                              const XML_Char *value,
-                              int value_length,
-                              const XML_Char *base,
-                              const XML_Char *systemId,
-                              const XML_Char *publicId,
-                              const XML_Char *notationName);
+typedef void(XMLCALL *XML_EntityDeclHandler)(
+    void *userData, const XML_Char *entityName, int is_parameter_entity,
+    const XML_Char *value, int value_length, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
 
 XMLPARSEAPI(void)
-XML_SetEntityDeclHandler(XML_Parser parser,
-                         XML_EntityDeclHandler handler);
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
 
 /* OBSOLETE -- OBSOLETE -- OBSOLETE
    This handler has been superseded by the EntityDeclHandler above.
@@ -379,24 +348,20 @@ XML_SetEntityDeclHandler(XML_Parser parser,
    entityName, systemId and notationName arguments will never be
    NULL. The other arguments may be.
 */
-typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (
-                                    void *userData,
-                                    const XML_Char *entityName,
-                                    const XML_Char *base,
-                                    const XML_Char *systemId,
-                                    const XML_Char *publicId,
-                                    const XML_Char *notationName);
+typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)(
+    void *userData, const XML_Char *entityName, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
 
 /* This is called for a declaration of notation.  The base argument is
    whatever was set by XML_SetBase. The notationName will never be
    NULL.  The other arguments can be.
 */
-typedef void (XMLCALL *XML_NotationDeclHandler) (
-                                    void *userData,
-                                    const XML_Char *notationName,
-                                    const XML_Char *base,
-                                    const XML_Char *systemId,
-                                    const XML_Char *publicId);
+typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
+                                               const XML_Char *notationName,
+                                               const XML_Char *base,
+                                               const XML_Char *systemId,
+                                               const XML_Char *publicId);
 
 /* When namespace processing is enabled, these are called once for
    each namespace declaration. The call to the start and end element
@@ -404,14 +369,12 @@ typedef void (XMLCALL *XML_NotationDeclHandler) (
    declaration handlers. For an xmlns attribute, prefix will be
    NULL.  For an xmlns="" attribute, uri will be NULL.
 */
-typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (
-                                    void *userData,
-                                    const XML_Char *prefix,
-                                    const XML_Char *uri);
+typedef void(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
+                                                     const XML_Char *prefix,
+                                                     const XML_Char *uri);
 
-typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
-                                    void *userData,
-                                    const XML_Char *prefix);
+typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
+                                                   const XML_Char *prefix);
 
 /* This is called if the document is not standalone, that is, it has an
    external subset or a reference to a parameter entity, but does not
@@ -422,7 +385,7 @@ typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
    conditions above this handler will only be called if the referenced
    entity was actually read.
 */
-typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
+typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData);
 
 /* This is called for a reference to an external parsed general
    entity.  The referenced entity is not automatically parsed.  The
@@ -458,12 +421,11 @@ typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
    Note that unlike other handlers the first argument is the parser,
    not userData.
 */
-typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
-                                    XML_Parser parser,
-                                    const XML_Char *context,
-                                    const XML_Char *base,
-                                    const XML_Char *systemId,
-                                    const XML_Char *publicId);
+typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
+                                                   const XML_Char *context,
+                                                   const XML_Char *base,
+                                                   const XML_Char *systemId,
+                                                   const XML_Char *publicId);
 
 /* This is called in two situations:
    1) An entity reference is encountered for which no declaration
@@ -475,10 +437,9 @@ typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
          the event would be out of sync with the reporting of the
          declarations or attribute values
 */
-typedef void (XMLCALL *XML_SkippedEntityHandler) (
-                                    void *userData,
-                                    const XML_Char *entityName,
-                                    int is_parameter_entity);
+typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
+                                                const XML_Char *entityName,
+                                                int is_parameter_entity);
 
 /* This structure is filled in by the XML_UnknownEncodingHandler to
    provide information to the parser about encodings that are unknown
@@ -535,8 +496,8 @@ typedef void (XMLCALL *XML_SkippedEntityHandler) (
 typedef struct {
   int map[256];
   void *data;
-  int (XMLCALL *convert)(void *data, const char *s);
-  void (XMLCALL *release)(void *data);
+  int(XMLCALL *convert)(void *data, const char *s);
+  void(XMLCALL *release)(void *data);
 } XML_Encoding;
 
 /* This is called for an encoding that is unknown to the parser.
@@ -554,23 +515,19 @@ typedef struct {
    If info does not describe a suitable encoding, then the parser will
    return an XML_UNKNOWN_ENCODING error.
 */
-typedef int (XMLCALL *XML_UnknownEncodingHandler) (
-                                    void *encodingHandlerData,
-                                    const XML_Char *name,
-                                    XML_Encoding *info);
+typedef int(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                                                 const XML_Char *name,
+                                                 XML_Encoding *info);
 
 XMLPARSEAPI(void)
-XML_SetElementHandler(XML_Parser parser,
-                      XML_StartElementHandler start,
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
                       XML_EndElementHandler end);
 
 XMLPARSEAPI(void)
-XML_SetStartElementHandler(XML_Parser parser,
-                           XML_StartElementHandler handler);
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);
 
 XMLPARSEAPI(void)
-XML_SetEndElementHandler(XML_Parser parser,
-                         XML_EndElementHandler handler);
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
 
 XMLPARSEAPI(void)
 XML_SetCharacterDataHandler(XML_Parser parser,
@@ -580,8 +537,7 @@ XMLPARSEAPI(void)
 XML_SetProcessingInstructionHandler(XML_Parser parser,
                                     XML_ProcessingInstructionHandler handler);
 XMLPARSEAPI(void)
-XML_SetCommentHandler(XML_Parser parser,
-                      XML_CommentHandler handler);
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
 
 XMLPARSEAPI(void)
 XML_SetCdataSectionHandler(XML_Parser parser,
@@ -601,20 +557,17 @@ XML_SetEndCdataSectionHandler(XML_Parser parser,
    default handler, or to the skipped entity handler, if one is set.
 */
 XMLPARSEAPI(void)
-XML_SetDefaultHandler(XML_Parser parser,
-                      XML_DefaultHandler handler);
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
 
 /* This sets the default handler but does not inhibit expansion of
    internal entities.  The entity reference will not be passed to the
    default handler.
 */
 XMLPARSEAPI(void)
-XML_SetDefaultHandlerExpand(XML_Parser parser,
-                            XML_DefaultHandler handler);
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
 
 XMLPARSEAPI(void)
-XML_SetDoctypeDeclHandler(XML_Parser parser,
-                          XML_StartDoctypeDeclHandler start,
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
                           XML_EndDoctypeDeclHandler end);
 
 XMLPARSEAPI(void)
@@ -622,16 +575,14 @@ XML_SetStartDoctypeDeclHandler(XML_Parser parser,
                                XML_StartDoctypeDeclHandler start);
 
 XMLPARSEAPI(void)
-XML_SetEndDoctypeDeclHandler(XML_Parser parser,
-                             XML_EndDoctypeDeclHandler end);
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);
 
 XMLPARSEAPI(void)
 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
                                  XML_UnparsedEntityDeclHandler handler);
 
 XMLPARSEAPI(void)
-XML_SetNotationDeclHandler(XML_Parser parser,
-                           XML_NotationDeclHandler handler);
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);
 
 XMLPARSEAPI(void)
 XML_SetNamespaceDeclHandler(XML_Parser parser,
@@ -659,8 +610,7 @@ XML_SetExternalEntityRefHandler(XML_Parser parser,
    instead of the parser object.
 */
 XMLPARSEAPI(void)
-XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
-                                   void *arg);
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
 
 XMLPARSEAPI(void)
 XML_SetSkippedEntityHandler(XML_Parser parser,
@@ -740,7 +690,6 @@ XML_UseParserAsHandlerArg(XML_Parser parser);
 XMLPARSEAPI(enum XML_Error)
 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
 
-
 /* Sets the base to be used for resolving relative URIs in system
    identifiers in declarations.  Resolving relative identifiers is
    left to the application: this value will be passed through as the
@@ -780,10 +729,10 @@ XML_GetIdAttributeIndex(XML_Parser parser);
    info->valueEnd - info->valueStart = 4 bytes.
 */
 typedef struct {
-  XML_Index  nameStart;  /* Offset to beginning of the attribute name. */
-  XML_Index  nameEnd;    /* Offset after the attribute name's last byte. */
-  XML_Index  valueStart; /* Offset to beginning of the attribute value. */
-  XML_Index  valueEnd;   /* Offset after the attribute value's last byte. */
+  XML_Index nameStart;  /* Offset to beginning of the attribute name. */
+  XML_Index nameEnd;    /* Offset after the attribute name's last byte. */
+  XML_Index valueStart; /* Offset to beginning of the attribute value. */
+  XML_Index valueEnd;   /* Offset after the attribute value's last byte. */
 } XML_AttrInfo;
 
 /* Returns an array of XML_AttrInfo structures for the attribute/value pairs
@@ -819,20 +768,20 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
    (resumable = 0) an already suspended parser. Some call-backs may
    still follow because they would otherwise get lost. Examples:
    - endElementHandler() for empty elements when stopped in
-     startElementHandler(), 
-   - endNameSpaceDeclHandler() when stopped in endElementHandler(), 
+     startElementHandler(),
+   - endNameSpaceDeclHandler() when stopped in endElementHandler(),
    and possibly others.
 
    Can be called from most handlers, including DTD related call-backs,
    except when parsing an external parameter entity and resumable != 0.
    Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
-   Possible error codes: 
+   Possible error codes:
    - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
    - XML_ERROR_FINISHED: when the parser has already finished.
    - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
 
-   When resumable != 0 (true) then parsing is suspended, that is, 
-   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED. 
+   When resumable != 0 (true) then parsing is suspended, that is,
+   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
    Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
    return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
 
@@ -843,7 +792,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
    the externalEntityRefHandler() to call XML_StopParser() on the parent
    parser (recursively), if one wants to stop parsing altogether.
 
-   When suspended, parsing can be resumed by calling XML_ResumeParser(). 
+   When suspended, parsing can be resumed by calling XML_ResumeParser().
 */
 XMLPARSEAPI(enum XML_Status)
 XML_StopParser(XML_Parser parser, XML_Bool resumable);
@@ -851,7 +800,7 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
 /* Resumes parsing after it has been suspended with XML_StopParser().
    Must not be called from within a handler call-back. Returns same
    status codes as XML_Parse() or XML_ParseBuffer().
-   Additional error code XML_ERROR_NOT_SUSPENDED possible.   
+   Additional error code XML_ERROR_NOT_SUSPENDED possible.
 
    *Note*:
    This must be called on the most deeply nested child parser instance
@@ -863,12 +812,7 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
 XMLPARSEAPI(enum XML_Status)
 XML_ResumeParser(XML_Parser parser);
 
-enum XML_Parsing {
-  XML_INITIALIZED,
-  XML_PARSING,
-  XML_FINISHED,
-  XML_SUSPENDED
-};
+enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
 
 typedef struct {
   enum XML_Parsing parsing;
@@ -900,8 +844,7 @@ XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
    Otherwise returns a new XML_Parser object.
 */
 XMLPARSEAPI(XML_Parser)
-XML_ExternalEntityParserCreate(XML_Parser parser,
-                               const XML_Char *context,
+XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
                                const XML_Char *encoding);
 
 enum XML_ParamEntityParsing {
@@ -945,8 +888,7 @@ XML_SetParamEntityParsing(XML_Parser parser,
    Note: If parser == NULL, the function will do nothing and return 0.
 */
 XMLPARSEAPI(int)
-XML_SetHashSalt(XML_Parser parser,
-                unsigned long hash_salt);
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
 
 /* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
    XML_GetErrorCode returns information about the error.
@@ -963,7 +905,7 @@ XML_GetErrorCode(XML_Parser parser);
    be within the relevant markup.  When called outside of the callback
    functions, the position indicated will be just past the last parse
    event (regardless of whether there was an associated callback).
-   
+
    They may also be called after returning from a call to XML_Parse
    or XML_ParseBuffer.  If the return value is XML_STATUS_ERROR then
    the location is the location of the character at which the error
@@ -995,14 +937,12 @@ XML_GetCurrentByteCount(XML_Parser parser);
    the handler that makes the call.
 */
 XMLPARSEAPI(const char *)
-XML_GetInputContext(XML_Parser parser,
-                    int *offset,
-                    int *size);
+XML_GetInputContext(XML_Parser parser, int *offset, int *size);
 
 /* For backwards compatibility with previous versions. */
-#define XML_GetErrorLineNumber   XML_GetCurrentLineNumber
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
 #define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
-#define XML_GetErrorByteIndex    XML_GetCurrentByteIndex
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
 
 /* Frees the content model passed to the element declaration handler */
 XMLPARSEAPI(void)
@@ -1062,21 +1002,20 @@ enum XML_FeatureEnum {
 };
 
 typedef struct {
-  enum XML_FeatureEnum  feature;
-  const XML_LChar       *name;
-  long int              value;
+  enum XML_FeatureEnum feature;
+  const XML_LChar *name;
+  long int value;
 } XML_Feature;
 
 XMLPARSEAPI(const XML_Feature *)
 XML_GetFeatureList(void);
 
-
 /* Expat follows the semantic versioning convention.
    See http://semver.org.
 */
 #define XML_MAJOR_VERSION 2
 #define XML_MINOR_VERSION 2
-#define XML_MICRO_VERSION 6
+#define XML_MICRO_VERSION 9
 
 #ifdef __cplusplus
 }
diff --git a/contrib/expat/lib/expat_external.h b/contrib/expat/lib/expat_external.h
index 629483a91b27..b3b6e74d9d20 100644
--- a/contrib/expat/lib/expat_external.h
+++ b/contrib/expat/lib/expat_external.h
@@ -35,10 +35,6 @@
 
 /* External API definitions */
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
-# define XML_USE_MSC_EXTENSIONS 1
-#endif
-
 /* Expat tries very hard to make the API boundary very specifically
    defined.  There are two macros defined to control this boundary;
    each of these can be defined before including this header to
@@ -62,11 +58,11 @@
    system headers may assume the cdecl convention.
 */
 #ifndef XMLCALL
-# if defined(_MSC_VER)
-#  define XMLCALL __cdecl
-# elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
-#  define XMLCALL __attribute__((cdecl))
-# else
+#  if defined(_MSC_VER)
+#    define XMLCALL __cdecl
+#  elif defined(__GNUC__) && defined(__i386) && ! defined(__INTEL_COMPILER)
+#    define XMLCALL __attribute__((cdecl))
+#  else
 /* For any platform which uses this definition and supports more than
    one calling convention, we need to extend this definition to
    declare the convention used on that platform, if it's possible to
@@ -77,41 +73,46 @@
    pre-processor and how to specify the same calling convention as the
    platform's malloc() implementation.
 */
-#  define XMLCALL
-# endif
-#endif  /* not defined XMLCALL */
-
+#    define XMLCALL
+#  endif
+#endif /* not defined XMLCALL */
 
-#if !defined(XML_STATIC) && !defined(XMLIMPORT)
-# ifndef XML_BUILDING_EXPAT
+#if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
+#  ifndef XML_BUILDING_EXPAT
 /* using Expat from an application */
 
-#  ifdef XML_USE_MSC_EXTENSIONS
-#   define XMLIMPORT __declspec(dllimport)
+#    if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
+#      define XMLIMPORT __declspec(dllimport)
+#    endif
+
 #  endif
+#endif /* not defined XML_STATIC */
 
-# endif
-#endif  /* not defined XML_STATIC */
+#ifndef XML_ENABLE_VISIBILITY
+#  define XML_ENABLE_VISIBILITY 0
+#endif
 
-#if !defined(XMLIMPORT) && defined(__GNUC__) && (__GNUC__ >= 4)
-# define XMLIMPORT __attribute__ ((visibility ("default")))
+#if ! defined(XMLIMPORT) && XML_ENABLE_VISIBILITY
+#  define XMLIMPORT __attribute__((visibility("default")))
 #endif
 
 /* If we didn't define it above, define it away: */
 #ifndef XMLIMPORT
-# define XMLIMPORT
+#  define XMLIMPORT
 #endif
 
-#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
-# define XML_ATTR_MALLOC __attribute__((__malloc__))
+#if defined(__GNUC__)                                                          \
+    && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
+#  define XML_ATTR_MALLOC __attribute__((__malloc__))
 #else
-# define XML_ATTR_MALLOC
+#  define XML_ATTR_MALLOC
 #endif
 
-#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-# define XML_ATTR_ALLOC_SIZE(x)  __attribute__((__alloc_size__(x)))
+#if defined(__GNUC__)                                                          \
+    && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#  define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
 #else
-# define XML_ATTR_ALLOC_SIZE(x)
+#  define XML_ATTR_ALLOC_SIZE(x)
 #endif
 
 #define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
@@ -121,35 +122,30 @@ extern "C" {
 #endif
 
 #ifdef XML_UNICODE_WCHAR_T
-# ifndef XML_UNICODE
-#  define XML_UNICODE
-# endif
-# if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
-#  error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
-# endif
+#  ifndef XML_UNICODE
+#    define XML_UNICODE
+#  endif
+#  if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
+#    error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
+#  endif
 #endif
 
-#ifdef XML_UNICODE     /* Information is UTF-16 encoded. */
-# ifdef XML_UNICODE_WCHAR_T
+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
+#  ifdef XML_UNICODE_WCHAR_T
 typedef wchar_t XML_Char;
 typedef wchar_t XML_LChar;
-# else
+#  else
 typedef unsigned short XML_Char;
 typedef char XML_LChar;
-# endif /* XML_UNICODE_WCHAR_T */
-#else                  /* Information is UTF-8 encoded. */
+#  endif /* XML_UNICODE_WCHAR_T */
+#else    /* Information is UTF-8 encoded. */
 typedef char XML_Char;
 typedef char XML_LChar;
-#endif /* XML_UNICODE */
+#endif   /* XML_UNICODE */
 
-#ifdef XML_LARGE_SIZE  /* Use large integers for file/stream positions. */
-# if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
-typedef __int64 XML_Index; 
-typedef unsigned __int64 XML_Size;
-# else
+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
 typedef long long XML_Index;
 typedef unsigned long long XML_Size;
-# endif
 #else
 typedef long XML_Index;
 typedef unsigned long XML_Size;
diff --git a/contrib/expat/lib/iasciitab.h b/contrib/expat/lib/iasciitab.h
index ce4a4bf7edef..ea97cfcf678e 100644
--- a/contrib/expat/lib/iasciitab.h
+++ b/contrib/expat/lib/iasciitab.h
@@ -32,34 +32,34 @@
 
 /* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
 /* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
-/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
-/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
-/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
-/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
-/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
-/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
-/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
-/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
-/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
-/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
-/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
-/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
-/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+    /* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+    /* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+    /* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+    /* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+    /* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+    /* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+    /* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+    /* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+    /* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+    /* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+    /* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+    /* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+    /* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
diff --git a/contrib/expat/lib/internal.h b/contrib/expat/lib/internal.h
index e33fdcb0238d..60913dab762f 100644
--- a/contrib/expat/lib/internal.h
+++ b/contrib/expat/lib/internal.h
@@ -49,7 +49,7 @@
    USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
+#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
 /* We'll use this version by default only where we know it helps.
 
    regparm() generates warnings on Solaris boxes.   See SF bug #692878.
@@ -59,8 +59,8 @@
    #define FASTCALL __attribute__((stdcall, regparm(3)))
    and let's try this:
 */
-#define FASTCALL __attribute__((regparm(3)))
-#define PTRFASTCALL __attribute__((regparm(3)))
+#  define FASTCALL __attribute__((regparm(3)))
+#  define PTRFASTCALL __attribute__((regparm(3)))
 #endif
 
 /* Using __fastcall seems to have an unexpected negative effect under
@@ -74,50 +74,49 @@
 /* Make sure all of these are defined if they aren't already. */
 
 #ifndef FASTCALL
-#define FASTCALL
+#  define FASTCALL
 #endif
 
 #ifndef PTRCALL
-#define PTRCALL
+#  define PTRCALL
 #endif
 
 #ifndef PTRFASTCALL
-#define PTRFASTCALL
+#  define PTRFASTCALL
 #endif
 
 #ifndef XML_MIN_SIZE
-#if !defined(__cplusplus) && !defined(inline)
-#ifdef __GNUC__
-#define inline __inline
-#endif /* __GNUC__ */
-#endif
+#  if ! defined(__cplusplus) && ! defined(inline)
+#    ifdef __GNUC__
+#      define inline __inline
+#    endif /* __GNUC__ */
+#  endif
 #endif /* XML_MIN_SIZE */
 
 #ifdef __cplusplus
-#define inline inline
+#  define inline inline
 #else
-#ifndef inline
-#define inline
-#endif
+#  ifndef inline
+#    define inline
+#  endif
 #endif
 
 #ifndef UNUSED_P
-# ifdef __GNUC__
-#  define UNUSED_P(p) UNUSED_ ## p __attribute__((__unused__))
-# else
-#  define UNUSED_P(p) UNUSED_ ## p
-# endif
+#  define UNUSED_P(p) (void)p
 #endif
 
-
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-
+#ifdef XML_ENABLE_VISIBILITY
+#  if XML_ENABLE_VISIBILITY
+__attribute__((visibility("default")))
+#  endif
+#endif
 void
-_INTERNAL_trim_to_complete_utf8_characters(const char * from, const char ** fromLimRef);
-
+_INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                           const char **fromLimRef);
 
 #ifdef __cplusplus
 }
diff --git a/contrib/expat/lib/latin1tab.h b/contrib/expat/lib/latin1tab.h
index 95dfa52b1fbe..6f916041355a 100644
--- a/contrib/expat/lib/latin1tab.h
+++ b/contrib/expat/lib/latin1tab.h
@@ -31,34 +31,34 @@
 */
 
 /* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
-/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
-/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
-/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
-/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
-/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+    /* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+    /* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+    /* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+    /* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+    /* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+    /* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
diff --git a/contrib/expat/lib/nametab.h b/contrib/expat/lib/nametab.h
index bfa2bd38cd95..3681df348eeb 100644
--- a/contrib/expat/lib/nametab.h
+++ b/contrib/expat/lib/nametab.h
@@ -31,152 +31,106 @@
 */
 
 static const unsigned namingBitmap[] = {
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
-0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
-0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
-0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
-0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
-0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
-0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
-0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
-0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
-0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
-0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
-0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
-0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
-0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
-0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
-0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
-0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
-0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
-0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
-0x40000000, 0xF580C900, 0x00000007, 0x02010800,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
-0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
-0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
-0x00000000, 0x00004C40, 0x00000000, 0x00000000,
-0x00000007, 0x00000000, 0x00000000, 0x00000000,
-0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
-0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
-0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
-0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
-0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
-0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
-0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
-0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
-0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
-0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
-0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
-0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
-0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
-0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
-0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
-0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
-0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
-0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
-0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
-0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
-0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
-0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
-0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
-0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
-0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
-0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
-0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
-0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x00000000, 0x00000000,
-0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
-0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
-0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
+    0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+    0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+    0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
+    0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+    0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
+    0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+    0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
+    0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+    0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
+    0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+    0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
+    0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
+    0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
+    0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+    0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
+    0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
+    0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
+    0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+    0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
+    0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
+    0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+    0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
+    0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+    0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
+    0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+    0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
+    0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+    0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
+    0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+    0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
+    0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
+    0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+    0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+    0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x77FFFFFF,
 };
 static const unsigned char nmstrtPages[] = {
-0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
-0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
-0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
-0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x17,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 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,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-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, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
+    0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 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, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 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 char namePages[] = {
-0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
-0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
-0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13,
-0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x17,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 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,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
+    0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 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, 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, 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, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 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, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
 };
diff --git a/contrib/expat/lib/siphash.h b/contrib/expat/lib/siphash.h
index 4d6786d7839a..bfee65a332f1 100644
--- a/contrib/expat/lib/siphash.h
+++ b/contrib/expat/lib/siphash.h
@@ -11,6 +11,10 @@
  * --------------------------------------------------------------------------
  * HISTORY:
  *
+ * 2019-08-03  (Sebastian Pipping)
+ *   - Mark part of sip24_valid as to be excluded from clang-format
+ *   - Re-format code using clang-format 9
+ *
  * 2018-07-08  (Anton Maklakov)
  *   - Add "fall through" markers for GCC's -Wimplicit-fallthrough
  *
@@ -94,186 +98,186 @@
 #include <stddef.h> /* size_t */
 
 #if defined(_WIN32) && defined(_MSC_VER) && (_MSC_VER < 1600)
-  /* For vs2003/7.1 up to vs2008/9.0; _MSC_VER 1600 is vs2010/10.0 */
-  typedef unsigned __int8   uint8_t;
-  typedef unsigned __int32 uint32_t;
-  typedef unsigned __int64 uint64_t;
+/* For vs2003/7.1 up to vs2008/9.0; _MSC_VER 1600 is vs2010/10.0 */
+typedef unsigned __int8 uint8_t;
+typedef unsigned __int32 uint32_t;
+typedef unsigned __int64 uint64_t;
 #else
- #include <stdint.h> /* uint64_t uint32_t uint8_t */
+#  include <stdint.h> /* uint64_t uint32_t uint8_t */
 #endif
 
-
 /*
  * Workaround to not require a C++11 compiler for using ULL suffix
  * if this code is included and compiled as C++; related GCC warning is:
  * warning: use of C++11 long long integer constant [-Wlong-long]
  */
-#define _SIP_ULL(high, low)  (((uint64_t)high << 32) | low)
-
-
-#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ( (x) >> (64 - (b))))
+#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
 
-#define SIP_U32TO8_LE(p, v) \
-	(p)[0] = (uint8_t)((v) >>  0); (p)[1] = (uint8_t)((v) >>  8); \
-	(p)[2] = (uint8_t)((v) >> 16); (p)[3] = (uint8_t)((v) >> 24);
+#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
-#define SIP_U64TO8_LE(p, v) \
-	SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >>  0)); \
-	SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+#define SIP_U32TO8_LE(p, v)                                                    \
+  (p)[0] = (uint8_t)((v) >> 0);                                                \
+  (p)[1] = (uint8_t)((v) >> 8);                                                \
+  (p)[2] = (uint8_t)((v) >> 16);                                               \
+  (p)[3] = (uint8_t)((v) >> 24);
 
-#define SIP_U8TO64_LE(p) \
-	(((uint64_t)((p)[0]) <<  0) | \
-	 ((uint64_t)((p)[1]) <<  8) | \
-	 ((uint64_t)((p)[2]) << 16) | \
-	 ((uint64_t)((p)[3]) << 24) | \
-	 ((uint64_t)((p)[4]) << 32) | \
-	 ((uint64_t)((p)[5]) << 40) | \
-	 ((uint64_t)((p)[6]) << 48) | \
-	 ((uint64_t)((p)[7]) << 56))
+#define SIP_U64TO8_LE(p, v)                                                    \
+  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
+  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
 
+#define SIP_U8TO64_LE(p)                                                       \
+  (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8)                       \
+   | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24)                   \
+   | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40)                   \
+   | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
 
-#define SIPHASH_INITIALIZER { 0, 0, 0, 0, { 0 }, 0, 0 }
+#define SIPHASH_INITIALIZER                                                    \
+  { 0, 0, 0, 0, {0}, 0, 0 }
 
 struct siphash {
-	uint64_t v0, v1, v2, v3;
+  uint64_t v0, v1, v2, v3;
 
-	unsigned char buf[8], *p;
-	uint64_t c;
+  unsigned char buf[8], *p;
+  uint64_t c;
 }; /* struct siphash */
 
-
 #define SIP_KEYLEN 16
 
 struct sipkey {
-	uint64_t k[2];
+  uint64_t k[2];
 }; /* struct sipkey */
 
-#define sip_keyof(k) sip_tokey(&(struct sipkey){ { 0 } }, (k))
+#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
 
-static struct sipkey *sip_tokey(struct sipkey *key, const void *src) {
-	key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
-	key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
-	return key;
+static struct sipkey *
+sip_tokey(struct sipkey *key, const void *src) {
+  key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
+  key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
+  return key;
 } /* sip_tokey() */
 
-
 #ifdef SIPHASH_TOBIN
 
-#define sip_binof(v) sip_tobin((unsigned char[8]){ 0 }, (v))
+#  define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
 
-static void *sip_tobin(void *dst, uint64_t u64) {
-	SIP_U64TO8_LE((unsigned char *)dst, u64);
-	return dst;
+static void *
+sip_tobin(void *dst, uint64_t u64) {
+  SIP_U64TO8_LE((unsigned char *)dst, u64);
+  return dst;
 } /* sip_tobin() */
 
-#endif  /* SIPHASH_TOBIN */
-
+#endif /* SIPHASH_TOBIN */
 
-static void sip_round(struct siphash *H, const int rounds) {
-	int i;
+static void
+sip_round(struct siphash *H, const int rounds) {
+  int i;
 
-	for (i = 0; i < rounds; i++) {
-		H->v0 += H->v1;
-		H->v1 = SIP_ROTL(H->v1, 13);
-		H->v1 ^= H->v0;
-		H->v0 = SIP_ROTL(H->v0, 32);
+  for (i = 0; i < rounds; i++) {
+    H->v0 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 13);
+    H->v1 ^= H->v0;
+    H->v0 = SIP_ROTL(H->v0, 32);
 
-		H->v2 += H->v3;
-		H->v3 = SIP_ROTL(H->v3, 16);
-		H->v3 ^= H->v2;
+    H->v2 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 16);
+    H->v3 ^= H->v2;
 
-		H->v0 += H->v3;
-		H->v3 = SIP_ROTL(H->v3, 21);
-		H->v3 ^= H->v0;
+    H->v0 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 21);
+    H->v3 ^= H->v0;
 
-		H->v2 += H->v1;
-		H->v1 = SIP_ROTL(H->v1, 17);
-		H->v1 ^= H->v2;
-		H->v2 = SIP_ROTL(H->v2, 32);
-	}
+    H->v2 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 17);
+    H->v1 ^= H->v2;
+    H->v2 = SIP_ROTL(H->v2, 32);
+  }
 } /* sip_round() */
 
+static struct siphash *
+sip24_init(struct siphash *H, const struct sipkey *key) {
+  H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
+  H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
+  H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
+  H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
 
-static struct siphash *sip24_init(struct siphash *H,
-		const struct sipkey *key) {
-	H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
-	H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
-	H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
-	H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
+  H->p = H->buf;
+  H->c = 0;
 
-	H->p = H->buf;
-	H->c = 0;
-
-	return H;
+  return H;
 } /* sip24_init() */
 
+#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
 
-#define sip_endof(a) (&(a)[sizeof (a) / sizeof *(a)])
-
-static struct siphash *sip24_update(struct siphash *H, const void *src,
-		size_t len) {
-	const unsigned char *p = (const unsigned char *)src, *pe = p + len;
-	uint64_t m;
+static struct siphash *
+sip24_update(struct siphash *H, const void *src, size_t len) {
+  const unsigned char *p = (const unsigned char *)src, *pe = p + len;
+  uint64_t m;
 
-	do {
-		while (p < pe && H->p < sip_endof(H->buf))
-			*H->p++ = *p++;
+  do {
+    while (p < pe && H->p < sip_endof(H->buf))
+      *H->p++ = *p++;
 
-		if (H->p < sip_endof(H->buf))
-			break;
+    if (H->p < sip_endof(H->buf))
+      break;
 
-		m = SIP_U8TO64_LE(H->buf);
-		H->v3 ^= m;
-		sip_round(H, 2);
-		H->v0 ^= m;
+    m = SIP_U8TO64_LE(H->buf);
+    H->v3 ^= m;
+    sip_round(H, 2);
+    H->v0 ^= m;
 
-		H->p = H->buf;
-		H->c += 8;
-	} while (p < pe);
+    H->p = H->buf;
+    H->c += 8;
+  } while (p < pe);
 
-	return H;
+  return H;
 } /* sip24_update() */
 
-
-static uint64_t sip24_final(struct siphash *H) {
-	const char left = (char)(H->p - H->buf);
-	uint64_t b = (H->c + left) << 56;
-
-	switch (left) {
-	case 7: b |= (uint64_t)H->buf[6] << 48;
-		/* fall through */
-	case 6: b |= (uint64_t)H->buf[5] << 40;
-		/* fall through */
-	case 5: b |= (uint64_t)H->buf[4] << 32;
-		/* fall through */
-	case 4: b |= (uint64_t)H->buf[3] << 24;
-		/* fall through */
-	case 3: b |= (uint64_t)H->buf[2] << 16;
-		/* fall through */
-	case 2: b |= (uint64_t)H->buf[1] << 8;
-		/* fall through */
-	case 1: b |= (uint64_t)H->buf[0] << 0;
-		/* fall through */
-	case 0: break;
-	}
-
-	H->v3 ^= b;
-	sip_round(H, 2);
-	H->v0 ^= b;
-	H->v2 ^= 0xff;
-	sip_round(H, 4);
-
-	return H->v0 ^ H->v1 ^ H->v2  ^ H->v3;
+static uint64_t
+sip24_final(struct siphash *H) {
+  const char left = (char)(H->p - H->buf);
+  uint64_t b = (H->c + left) << 56;
+
+  switch (left) {
+  case 7:
+    b |= (uint64_t)H->buf[6] << 48;
+    /* fall through */
+  case 6:
+    b |= (uint64_t)H->buf[5] << 40;
+    /* fall through */
+  case 5:
+    b |= (uint64_t)H->buf[4] << 32;
+    /* fall through */
+  case 4:
+    b |= (uint64_t)H->buf[3] << 24;
+    /* fall through */
+  case 3:
+    b |= (uint64_t)H->buf[2] << 16;
+    /* fall through */
+  case 2:
+    b |= (uint64_t)H->buf[1] << 8;
+    /* fall through */
+  case 1:
+    b |= (uint64_t)H->buf[0] << 0;
+    /* fall through */
+  case 0:
+    break;
+  }
+
+  H->v3 ^= b;
+  sip_round(H, 2);
+  H->v0 ^= b;
+  H->v2 ^= 0xff;
+  sip_round(H, 4);
+
+  return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
 } /* sip24_final() */
 
-
-static uint64_t siphash24(const void *src, size_t len,
-		const struct sipkey *key) {
-	struct siphash state = SIPHASH_INITIALIZER;
-	return sip24_final(sip24_update(sip24_init(&state, key), src, len));
+static uint64_t
+siphash24(const void *src, size_t len, const struct sipkey *key) {
+  struct siphash state = SIPHASH_INITIALIZER;
+  return sip24_final(sip24_update(sip24_init(&state, key), src, len));
 } /* siphash24() */
 
-
 /*
  * SipHash-2-4 output with
  * k = 00 01 02 ...
@@ -285,107 +289,110 @@ static uint64_t siphash24(const void *src, size_t len,
  * ...
  * in = 00 01 02 ... 3e (63 bytes)
  */
-static int sip24_valid(void) {
-	static const unsigned char vectors[64][8] = {
-		{ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
-		{ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
-		{ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
-		{ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
-		{ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
-		{ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
-		{ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
-		{ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
-		{ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
-		{ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
-		{ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
-		{ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
-		{ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
-		{ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
-		{ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
-		{ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
-		{ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
-		{ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
-		{ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
-		{ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
-		{ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
-		{ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
-		{ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
-		{ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
-		{ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
-		{ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
-		{ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
-		{ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
-		{ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
-		{ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
-		{ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
-		{ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
-		{ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
-		{ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
-		{ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
-		{ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
-		{ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
-		{ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
-		{ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
-		{ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
-		{ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
-		{ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
-		{ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
-		{ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
-		{ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
-		{ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
-		{ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
-		{ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
-		{ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
-		{ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
-		{ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
-		{ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
-		{ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
-		{ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
-		{ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
-		{ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
-		{ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
-		{ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
-		{ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
-		{ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
-		{ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
-		{ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
-		{ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
-		{ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
-	};
-	unsigned char in[64];
-	struct sipkey k;
-	size_t i;
-
-	sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
-			"\012\013\014\015\016\017");
-
-	for (i = 0; i < sizeof in; ++i) {
-		in[i] = (unsigned char)i;
-
-		if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
-			return 0;
-	}
-
-	return 1;
+static int
+sip24_valid(void) {
+  /* clang-format off */
+  static const unsigned char vectors[64][8] = {
+    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
+    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
+    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
+    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
+    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
+    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
+    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
+    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
+    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
+    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
+    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
+    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
+    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
+    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
+    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
+    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
+    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
+    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
+    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
+    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
+    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
+    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
+    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
+    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
+    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
+    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
+    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
+    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
+    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
+    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
+    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
+    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
+    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
+    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
+    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
+    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
+    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
+    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
+    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
+    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
+    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
+    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
+    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
+    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
+    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
+    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
+    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
+    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
+    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
+    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
+    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
+    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
+    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
+    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
+    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
+    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
+    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
+    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
+    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
+    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
+    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
+    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
+    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
+    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
+  };
+  /* clang-format on */
+
+  unsigned char in[64];
+  struct sipkey k;
+  size_t i;
+
+  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
+                "\012\013\014\015\016\017");
+
+  for (i = 0; i < sizeof in; ++i) {
+    in[i] = (unsigned char)i;
+
+    if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
+      return 0;
+  }
+
+  return 1;
 } /* sip24_valid() */
 
-
 #ifdef SIPHASH_MAIN
 
-#include <stdio.h>
+#  include <stdio.h>
 
-int main(void) {
-	const int ok = sip24_valid();
+int
+main(void) {
+  const int ok = sip24_valid();
 
-	if (ok)
-		puts("OK");
-	else
-		puts("FAIL");
+  if (ok)
+    puts("OK");
+  else
+    puts("FAIL");
 
-	return !ok;
+  return ! ok;
 } /* main() */
 
 #endif /* SIPHASH_MAIN */
 
-
 #endif /* SIPHASH_H */
diff --git a/contrib/expat/lib/utf8tab.h b/contrib/expat/lib/utf8tab.h
index fa0bed6f5d75..a22986acbb95 100644
--- a/contrib/expat/lib/utf8tab.h
+++ b/contrib/expat/lib/utf8tab.h
@@ -31,34 +31,34 @@
 */
 
 /* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
-/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
-/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
-/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
-/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
-/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
+    /* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+    /* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+    /* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+    /* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+    /* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+    /* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
diff --git a/contrib/expat/lib/xmlparse.c b/contrib/expat/lib/xmlparse.c
index e4ce52816ab9..3aaf35b94b1d 100644
--- a/contrib/expat/lib/xmlparse.c
+++ b/contrib/expat/lib/xmlparse.c
@@ -1,4 +1,4 @@
-/* 19ac4776051591216f1874e34ee99b6a43a3784c8bd7d70efeb9258dd22b906a (2.2.6+)
+/* f519f27c7c3b79fee55aeb8b1e53b7384b079d9118bf3a62eb3a60986a6742f2 (2.2.9+)
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
@@ -30,33 +30,40 @@
    USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#if !defined(_GNU_SOURCE)
-# define _GNU_SOURCE 1                  /* syscall prototype */
+#if ! defined(_GNU_SOURCE)
+#  define _GNU_SOURCE 1 /* syscall prototype */
+#endif
+
+#ifdef _WIN32
+/* force stdlib to define rand_s() */
+#  if ! defined(_CRT_RAND_S)
+#    define _CRT_RAND_S
+#  endif
 #endif
 
 #include <stddef.h>
-#include <string.h>                     /* memset(), memcpy() */
+#include <string.h> /* memset(), memcpy() */
 #include <assert.h>
-#include <limits.h>                     /* UINT_MAX */
-#include <stdio.h>                      /* fprintf */
-#include <stdlib.h>                     /* getenv */
+#include <limits.h> /* UINT_MAX */
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* getenv, rand_s */
 
 #ifdef _WIN32
-#define getpid GetCurrentProcessId
+#  define getpid GetCurrentProcessId
 #else
-#include <sys/time.h>                   /* gettimeofday() */
-#include <sys/types.h>                  /* getpid() */
-#include <unistd.h>                     /* getpid() */
-#include <fcntl.h>                      /* O_RDONLY */
-#include <errno.h>
+#  include <sys/time.h>  /* gettimeofday() */
+#  include <sys/types.h> /* getpid() */
+#  include <unistd.h>    /* getpid() */
+#  include <fcntl.h>     /* O_RDONLY */
+#  include <errno.h>
 #endif
 
 #define XML_BUILDING_EXPAT 1
 
 #ifdef _WIN32
-#include "winconfig.h"
+#  include "winconfig.h"
 #elif defined(HAVE_EXPAT_CONFIG_H)
-#include <expat_config.h>
+#  include <expat_config.h>
 #endif /* ndef _WIN32 */
 
 #include "ascii.h"
@@ -64,33 +71,31 @@
 #include "siphash.h"
 
 #if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
-# if defined(HAVE_GETRANDOM)
-#  include <sys/random.h>    /* getrandom */
-# else
-#  include <unistd.h>        /* syscall */
-#  include <sys/syscall.h>   /* SYS_getrandom */
-# endif
-# if ! defined(GRND_NONBLOCK)
-#  define GRND_NONBLOCK  0x0001
-# endif  /* defined(GRND_NONBLOCK) */
-#endif  /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
-
-#if defined(HAVE_LIBBSD) \
+#  if defined(HAVE_GETRANDOM)
+#    include <sys/random.h> /* getrandom */
+#  else
+#    include <unistd.h>      /* syscall */
+#    include <sys/syscall.h> /* SYS_getrandom */
+#  endif
+#  if ! defined(GRND_NONBLOCK)
+#    define GRND_NONBLOCK 0x0001
+#  endif /* defined(GRND_NONBLOCK) */
+#endif   /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#if defined(HAVE_LIBBSD)                                                       \
     && (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))
-# include <bsd/stdlib.h>
+#  include <bsd/stdlib.h>
 #endif
 
-#if defined(_WIN32) && !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
-# define LOAD_LIBRARY_SEARCH_SYSTEM32  0x00000800
+#if defined(_WIN32) && ! defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+#  define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
 #endif
 
-#if !defined(HAVE_GETRANDOM) && !defined(HAVE_SYSCALL_GETRANDOM) \
-    && !defined(HAVE_ARC4RANDOM_BUF) && !defined(HAVE_ARC4RANDOM) \
-    && !defined(XML_DEV_URANDOM) \
-    && !defined(_WIN32) \
-    && !defined(XML_POOR_ENTROPY)
-# error  \
-    You do not have support for any sources of high quality entropy \
+#if ! defined(HAVE_GETRANDOM) && ! defined(HAVE_SYSCALL_GETRANDOM)             \
+    && ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)            \
+    && ! defined(XML_DEV_URANDOM) && ! defined(_WIN32)                         \
+    && ! defined(XML_POOR_ENTROPY)
+#  error You do not have support for any sources of high quality entropy \
     enabled.  For end user security, that is probably not what you want. \
     \
     Your options include: \
@@ -101,7 +106,7 @@
       * libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \
       * libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \
       * Linux / BSD / macOS (/dev/urandom): XML_DEV_URANDOM \
-      * Windows (RtlGenRandom): _WIN32. \
+      * Windows (rand_s): _WIN32. \
     \
     If insist on not using any of these, bypass this error by defining \
     XML_POOR_ENTROPY; you have been warned. \
@@ -110,69 +115,59 @@
     to the build system, please open a bug.  Thank you!
 #endif
 
-
 #ifdef XML_UNICODE
-#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
-#define XmlConvert XmlUtf16Convert
-#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
-#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
-#define XmlEncode XmlUtf16Encode
+#  define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
+#  define XmlConvert XmlUtf16Convert
+#  define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
+#  define XmlEncode XmlUtf16Encode
 /* Using pointer subtraction to convert to integer type. */
-#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
+#  define MUST_CONVERT(enc, s)                                                 \
+    (! (enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
 typedef unsigned short ICHAR;
 #else
-#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
-#define XmlConvert XmlUtf8Convert
-#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
-#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
-#define XmlEncode XmlUtf8Encode
-#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
+#  define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
+#  define XmlConvert XmlUtf8Convert
+#  define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
+#  define XmlEncode XmlUtf8Encode
+#  define MUST_CONVERT(enc, s) (! (enc)->isUtf8)
 typedef char ICHAR;
 #endif
 
-
 #ifndef XML_NS
 
-#define XmlInitEncodingNS XmlInitEncoding
-#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
-#undef XmlGetInternalEncodingNS
-#define XmlGetInternalEncodingNS XmlGetInternalEncoding
-#define XmlParseXmlDeclNS XmlParseXmlDecl
+#  define XmlInitEncodingNS XmlInitEncoding
+#  define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
+#  undef XmlGetInternalEncodingNS
+#  define XmlGetInternalEncodingNS XmlGetInternalEncoding
+#  define XmlParseXmlDeclNS XmlParseXmlDecl
 
 #endif
 
 #ifdef XML_UNICODE
 
-#ifdef XML_UNICODE_WCHAR_T
-#define XML_T(x) (const wchar_t)x
-#define XML_L(x) L ## x
-#else
-#define XML_T(x) (const unsigned short)x
-#define XML_L(x) x
-#endif
+#  ifdef XML_UNICODE_WCHAR_T
+#    define XML_T(x) (const wchar_t) x
+#    define XML_L(x) L##x
+#  else
+#    define XML_T(x) (const unsigned short)x
+#    define XML_L(x) x
+#  endif
 
 #else
 
-#define XML_T(x) x
-#define XML_L(x) x
+#  define XML_T(x) x
+#  define XML_L(x) x
 
 #endif
 
 /* Round up n to be a multiple of sz, where sz is a power of 2. */
-#define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
+#define ROUND_UP(n, sz) (((n) + ((sz)-1)) & ~((sz)-1))
 
 /* Do safe (NULL-aware) pointer arithmetic */
 #define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)
 
-/* Handle the case where memmove() doesn't exist. */
-#ifndef HAVE_MEMMOVE
-#ifdef HAVE_BCOPY
-#define memmove(d,s,l) bcopy((s),(d),(l))
-#else
-#error memmove does not exist on this platform, nor is a substitute available
-#endif /* HAVE_BCOPY */
-#endif /* HAVE_MEMMOVE */
-
 #include "internal.h"
 #include "xmltok.h"
 #include "xmlrole.h"
@@ -191,11 +186,9 @@ typedef struct {
   const XML_Memory_Handling_Suite *mem;
 } HASH_TABLE;
 
-static size_t
-keylen(KEY s);
+static size_t keylen(KEY s);
 
-static void
-copy_salt_to_sipkey(XML_Parser parser, struct sipkey * key);
+static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
 
 /* For probing (after a collision) we need a step size relative prime
    to the hash table size, which is a power of 2. We use double-hashing,
@@ -205,9 +198,9 @@ copy_salt_to_sipkey(XML_Parser parser, struct sipkey * key);
    We limit the maximum step size to table->size / 4 (mask >> 2) and make
    it odd, since odd numbers are always relative prime to a power of 2.
 */
-#define SECOND_HASH(hash, mask, power) \
-  ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))
-#define PROBE_STEP(hash, mask, power) \
+#define SECOND_HASH(hash, mask, power)                                         \
+  ((((hash) & ~(mask)) >> ((power)-1)) & ((mask) >> 2))
+#define PROBE_STEP(hash, mask, power)                                          \
   ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
 
 typedef struct {
@@ -215,7 +208,7 @@ typedef struct {
   NAMED **end;
 } HASH_TABLE_ITER;
 
-#define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
+#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
 #define INIT_DATA_BUF_SIZE 1024
 #define INIT_ATTS_SIZE 16
 #define INIT_ATTS_VERSION 0xFFFFFFFF
@@ -262,20 +255,20 @@ typedef struct {
    TAG objects in a free list.
 */
 typedef struct tag {
-  struct tag *parent;           /* parent of this element */
-  const char *rawName;          /* tagName in the original encoding */
+  struct tag *parent;  /* parent of this element */
+  const char *rawName; /* tagName in the original encoding */
   int rawNameLength;
-  TAG_NAME name;                /* tagName in the API encoding */
-  char *buf;                    /* buffer for name components */
-  char *bufEnd;                 /* end of the buffer */
+  TAG_NAME name; /* tagName in the API encoding */
+  char *buf;     /* buffer for name components */
+  char *bufEnd;  /* end of the buffer */
   BINDING *bindings;
 } TAG;
 
 typedef struct {
   const XML_Char *name;
   const XML_Char *textPtr;
-  int textLen;                  /* length in XML_Chars */
-  int processed;                /* # of processed bytes - when suspended */
+  int textLen;   /* length in XML_Chars */
+  int processed; /* # of processed bytes - when suspended */
   const XML_Char *systemId;
   const XML_Char *base;
   const XML_Char *publicId;
@@ -286,13 +279,13 @@ typedef struct {
 } ENTITY;
 
 typedef struct {
-  enum XML_Content_Type         type;
-  enum XML_Content_Quant        quant;
-  const XML_Char *              name;
-  int                           firstchild;
-  int                           lastchild;
-  int                           childcnt;
-  int                           nextsib;
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  const XML_Char *name;
+  int firstchild;
+  int lastchild;
+  int childcnt;
+  int nextsib;
 } CONTENT_SCAFFOLD;
 
 #define INIT_SCAFFOLD_ELEMENTS 32
@@ -380,10 +373,8 @@ typedef struct open_internal_entity {
   XML_Bool betweenDecl; /* WFC: PE Between Declarations */
 } OPEN_INTERNAL_ENTITY;
 
-typedef enum XML_Error PTRCALL Processor(XML_Parser parser,
-                                         const char *start,
-                                         const char *end,
-                                         const char **endPtr);
+typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
+                                         const char *end, const char **endPtr);
 
 static Processor prologProcessor;
 static Processor prologInitProcessor;
@@ -404,118 +395,101 @@ static Processor externalEntityInitProcessor3;
 static Processor externalEntityContentProcessor;
 static Processor internalEntityProcessor;
 
-static enum XML_Error
-handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
-static enum XML_Error
-processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
-               const char *s, const char *next);
-static enum XML_Error
-initializeEncoding(XML_Parser parser);
-static enum XML_Error
-doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
-         const char *end, int tok, const char *next, const char **nextPtr,
-         XML_Bool haveMore);
-static enum XML_Error
-processInternalEntity(XML_Parser parser, ENTITY *entity,
-                      XML_Bool betweenDecl);
-static enum XML_Error
-doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
-          const char *start, const char *end, const char **endPtr,
-          XML_Bool haveMore);
-static enum XML_Error
-doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
-               const char *end, const char **nextPtr, XML_Bool haveMore);
+static enum XML_Error handleUnknownEncoding(XML_Parser parser,
+                                            const XML_Char *encodingName);
+static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+                                     const char *s, const char *next);
+static enum XML_Error initializeEncoding(XML_Parser parser);
+static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
+                               const char *s, const char *end, int tok,
+                               const char *next, const char **nextPtr,
+                               XML_Bool haveMore, XML_Bool allowClosingDoctype);
+static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
+                                            XML_Bool betweenDecl);
+static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
+                                const ENCODING *enc, const char *start,
+                                const char *end, const char **endPtr,
+                                XML_Bool haveMore);
+static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
+                                     const char **startPtr, const char *end,
+                                     const char **nextPtr, XML_Bool haveMore);
 #ifdef XML_DTD
-static enum XML_Error
-doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,
-                const char *end, const char **nextPtr, XML_Bool haveMore);
+static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
+                                      const char **startPtr, const char *end,
+                                      const char **nextPtr, XML_Bool haveMore);
 #endif /* XML_DTD */
 
-static void
-freeBindings(XML_Parser parser, BINDING *bindings);
-static enum XML_Error
-storeAtts(XML_Parser parser, const ENCODING *, const char *s,
-          TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
-static enum XML_Error
-addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
-           const XML_Char *uri, BINDING **bindingsPtr);
-static int
-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
-                XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
-static enum XML_Error
-storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
-                    const char *, const char *, STRING_POOL *);
-static enum XML_Error
-appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
-                     const char *, const char *, STRING_POOL *);
-static ATTRIBUTE_ID *
-getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
-               const char *end);
-static int
-setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
-static enum XML_Error
-storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,
-                 const char *end);
-static int
-reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
-                            const char *start, const char *end);
-static int
-reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
-              const char *end);
-static void
-reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,
-              const char *end);
-
-static const XML_Char * getContext(XML_Parser parser);
-static XML_Bool
-setContext(XML_Parser parser, const XML_Char *context);
+static void freeBindings(XML_Parser parser, BINDING *bindings);
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
+                                const char *s, TAG_NAME *tagNamePtr,
+                                BINDING **bindingsPtr);
+static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
+                                 const ATTRIBUTE_ID *attId, const XML_Char *uri,
+                                 BINDING **bindingsPtr);
+static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
+                           XML_Bool isId, const XML_Char *dfltValue,
+                           XML_Parser parser);
+static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
+                                          XML_Bool isCdata, const char *,
+                                          const char *, STRING_POOL *);
+static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
+                                           XML_Bool isCdata, const char *,
+                                           const char *, STRING_POOL *);
+static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
+                                    const char *start, const char *end);
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
+static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end);
+static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end);
+static int reportComment(XML_Parser parser, const ENCODING *enc,
+                         const char *start, const char *end);
+static void reportDefault(XML_Parser parser, const ENCODING *enc,
+                          const char *start, const char *end);
+
+static const XML_Char *getContext(XML_Parser parser);
+static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
 
 static void FASTCALL normalizePublicId(XML_Char *s);
 
-static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);
+static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);
 /* do not call if m_parentParser != NULL */
 static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
-static void
-dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
-static int
-dtdCopy(XML_Parser oldParser,
-        DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
-static int
-copyEntityTable(XML_Parser oldParser,
-                HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
-static NAMED *
-lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize);
-static void FASTCALL
-hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
+static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
+                       const XML_Memory_Handling_Suite *ms);
+static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+                   const XML_Memory_Handling_Suite *ms);
+static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *, STRING_POOL *,
+                           const HASH_TABLE *);
+static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
+                     size_t createSize);
+static void FASTCALL hashTableInit(HASH_TABLE *,
+                                   const XML_Memory_Handling_Suite *ms);
 static void FASTCALL hashTableClear(HASH_TABLE *);
 static void FASTCALL hashTableDestroy(HASH_TABLE *);
-static void FASTCALL
-hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
-static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
+static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
+static NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
 
-static void FASTCALL
-poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);
+static void FASTCALL poolInit(STRING_POOL *,
+                              const XML_Memory_Handling_Suite *ms);
 static void FASTCALL poolClear(STRING_POOL *);
 static void FASTCALL poolDestroy(STRING_POOL *);
-static XML_Char *
-poolAppend(STRING_POOL *pool, const ENCODING *enc,
-           const char *ptr, const char *end);
-static XML_Char *
-poolStoreString(STRING_POOL *pool, const ENCODING *enc,
-                const char *ptr, const char *end);
+static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+                            const char *ptr, const char *end);
+static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+                                 const char *ptr, const char *end);
 static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
-static const XML_Char * FASTCALL
-poolCopyString(STRING_POOL *pool, const XML_Char *s);
-static const XML_Char *
-poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
-static const XML_Char * FASTCALL
-poolAppendString(STRING_POOL *pool, const XML_Char *s);
+static const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,
+                                               const XML_Char *s);
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
+                                       int n);
+static const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,
+                                                 const XML_Char *s);
 
 static int FASTCALL nextScaffoldPart(XML_Parser parser);
-static XML_Content * build_model(XML_Parser parser);
-static ELEMENT_TYPE *
-getElementType(XML_Parser parser, const ENCODING *enc,
-               const char *ptr, const char *end);
+static XML_Content *build_model(XML_Parser parser);
+static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
+                                    const char *ptr, const char *end);
 
 static XML_Char *copyString(const XML_Char *s,
                             const XML_Memory_Handling_Suite *memsuite);
@@ -523,14 +497,11 @@ static XML_Char *copyString(const XML_Char *s,
 static unsigned long generate_hash_secret_salt(XML_Parser parser);
 static XML_Bool startParsing(XML_Parser parser);
 
-static XML_Parser
-parserCreate(const XML_Char *encodingName,
-             const XML_Memory_Handling_Suite *memsuite,
-             const XML_Char *nameSep,
-             DTD *dtd);
+static XML_Parser parserCreate(const XML_Char *encodingName,
+                               const XML_Memory_Handling_Suite *memsuite,
+                               const XML_Char *nameSep, DTD *dtd);
 
-static void
-parserInit(XML_Parser parser, const XML_Char *encodingName);
+static void parserInit(XML_Parser parser, const XML_Char *encodingName);
 
 #define poolStart(pool) ((pool)->start)
 #define poolEnd(pool) ((pool)->ptr)
@@ -539,10 +510,10 @@ parserInit(XML_Parser parser, const XML_Char *encodingName);
 #define poolLastChar(pool) (((pool)->ptr)[-1])
 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
 #define poolFinish(pool) ((pool)->start = (pool)->ptr)
-#define poolAppendChar(pool, c) \
-  (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
-   ? 0 \
-   : ((*((pool)->ptr)++ = c), 1))
+#define poolAppendChar(pool, c)                                                \
+  (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \
+       ? 0                                                                     \
+       : ((*((pool)->ptr)++ = c), 1))
 
 struct XML_ParserStruct {
   /* The first member must be m_userData so that the XML_GetUserData
@@ -593,7 +564,7 @@ struct XML_ParserStruct {
   void *m_unknownEncodingMem;
   void *m_unknownEncodingData;
   void *m_unknownEncodingHandlerData;
-  void (XMLCALL *m_unknownEncodingRelease)(void *);
+  void(XMLCALL *m_unknownEncodingRelease)(void *);
   PROLOG_STATE m_prologState;
   Processor *m_processor;
   enum XML_Error m_errorCode;
@@ -647,57 +618,55 @@ struct XML_ParserStruct {
   unsigned long m_hash_secret_salt;
 };
 
-#define MALLOC(parser, s)      (parser->m_mem.malloc_fcn((s)))
-#define REALLOC(parser, p, s)  (parser->m_mem.realloc_fcn((p),(s)))
-#define FREE(parser, p)        (parser->m_mem.free_fcn((p)))
-
+#define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
+#define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
+#define FREE(parser, p) (parser->m_mem.free_fcn((p)))
 
 XML_Parser XMLCALL
-XML_ParserCreate(const XML_Char *encodingName)
-{
+XML_ParserCreate(const XML_Char *encodingName) {
   return XML_ParserCreate_MM(encodingName, NULL, NULL);
 }
 
 XML_Parser XMLCALL
-XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
-{
+XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {
   XML_Char tmp[2];
   *tmp = nsSep;
   return XML_ParserCreate_MM(encodingName, NULL, tmp);
 }
 
-static const XML_Char implicitContext[] = {
-  ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
-  ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
-  ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
-  ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
-  ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
-  ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
-};
-
+static const XML_Char implicitContext[]
+    = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,
+       ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,
+       ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,
+       ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,
+       ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,
+       ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,
+       ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,
+       ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,
+       '\0'};
 
 /* To avoid warnings about unused functions: */
 #if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
 
-#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+#  if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
 
 /* Obtain entropy on Linux 3.17+ */
 static int
-writeRandomBytes_getrandom_nonblock(void * target, size_t count) {
-  int success = 0;  /* full count bytes written? */
+writeRandomBytes_getrandom_nonblock(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
   size_t bytesWrittenTotal = 0;
   const unsigned int getrandomFlags = GRND_NONBLOCK;
 
   do {
-    void * const currentTarget = (void*)((char*)target + bytesWrittenTotal);
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
     const size_t bytesToWrite = count - bytesWrittenTotal;
 
     const int bytesWrittenMore =
-#if defined(HAVE_GETRANDOM)
+#    if defined(HAVE_GETRANDOM)
         getrandom(currentTarget, bytesToWrite, getrandomFlags);
-#else
+#    else
         syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);
-#endif
+#    endif
 
     if (bytesWrittenMore > 0) {
       bytesWrittenTotal += bytesWrittenMore;
@@ -709,15 +678,14 @@ writeRandomBytes_getrandom_nonblock(void * target, size_t count) {
   return success;
 }
 
-#endif  /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
-
+#  endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
 
-#if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
 
 /* Extract entropy from /dev/urandom */
 static int
-writeRandomBytes_dev_urandom(void * target, size_t count) {
-  int success = 0;  /* full count bytes written? */
+writeRandomBytes_dev_urandom(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
   size_t bytesWrittenTotal = 0;
 
   const int fd = open("/dev/urandom", O_RDONLY);
@@ -726,7 +694,7 @@ writeRandomBytes_dev_urandom(void * target, size_t count) {
   }
 
   do {
-    void * const currentTarget = (void*)((char*)target + bytesWrittenTotal);
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
     const size_t bytesToWrite = count - bytesWrittenTotal;
 
     const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);
@@ -742,15 +710,14 @@ writeRandomBytes_dev_urandom(void * target, size_t count) {
   return success;
 }
 
-#endif  /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
-
-#endif  /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
 
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
 
 #if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)
 
 static void
-writeRandomBytes_arc4random(void * target, size_t count) {
+writeRandomBytes_arc4random(void *target, size_t count) {
   size_t bytesWrittenTotal = 0;
 
   while (bytesWrittenTotal < count) {
@@ -758,93 +725,82 @@ writeRandomBytes_arc4random(void * target, size_t count) {
     size_t i = 0;
 
     for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
-        i++, bytesWrittenTotal++) {
+         i++, bytesWrittenTotal++) {
       const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
       ((uint8_t *)target)[bytesWrittenTotal] = random8;
     }
   }
 }
 
-#endif  /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */
-
+#endif /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */
 
 #ifdef _WIN32
 
-typedef BOOLEAN (APIENTRY *RTLGENRANDOM_FUNC)(PVOID, ULONG);
-HMODULE _Expat_LoadLibrary(LPCTSTR filename);  /* see loadlibrary.c */
-
-/* Obtain entropy on Windows XP / Windows Server 2003 and later.
- * Hint on RtlGenRandom and the following article from libsodium.
- *
- * Michael Howard: Cryptographically Secure Random number on Windows without using CryptoAPI
- * https://blogs.msdn.microsoft.com/michael_howard/2005/01/14/cryptographically-secure-random-number-on-windows-without-using-cryptoapi/
+/* Obtain entropy on Windows using the rand_s() function which
+ * generates cryptographically secure random numbers.  Internally it
+ * uses RtlGenRandom API which is present in Windows XP and later.
  */
 static int
-writeRandomBytes_RtlGenRandom(void * target, size_t count) {
-  int success = 0;  /* full count bytes written? */
-  const HMODULE advapi32 = _Expat_LoadLibrary(TEXT("ADVAPI32.DLL"));
-
-  if (advapi32) {
-    const RTLGENRANDOM_FUNC RtlGenRandom
-        = (RTLGENRANDOM_FUNC)GetProcAddress(advapi32, "SystemFunction036");
-    if (RtlGenRandom) {
-      if (RtlGenRandom((PVOID)target, (ULONG)count) == TRUE) {
-        success = 1;
-      }
+writeRandomBytes_rand_s(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
+
+  while (bytesWrittenTotal < count) {
+    unsigned int random32 = 0;
+    size_t i = 0;
+
+    if (rand_s(&random32))
+      return 0; /* failure */
+
+    for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+         i++, bytesWrittenTotal++) {
+      const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+      ((uint8_t *)target)[bytesWrittenTotal] = random8;
     }
-    FreeLibrary(advapi32);
   }
-
-  return success;
+  return 1; /* success */
 }
 
 #endif /* _WIN32 */
 
-
 #if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
 
 static unsigned long
-gather_time_entropy(void)
-{
-#ifdef _WIN32
+gather_time_entropy(void) {
+#  ifdef _WIN32
   FILETIME ft;
   GetSystemTimeAsFileTime(&ft); /* never fails */
   return ft.dwHighDateTime ^ ft.dwLowDateTime;
-#else
+#  else
   struct timeval tv;
   int gettimeofday_res;
 
   gettimeofday_res = gettimeofday(&tv, NULL);
 
-#if defined(NDEBUG)
+#    if defined(NDEBUG)
   (void)gettimeofday_res;
-#else
-  assert (gettimeofday_res == 0);
-#endif  /* defined(NDEBUG) */
+#    else
+  assert(gettimeofday_res == 0);
+#    endif /* defined(NDEBUG) */
 
   /* Microseconds time is <20 bits entropy */
   return tv.tv_usec;
-#endif
+#  endif
 }
 
-#endif  /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
-
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
 
 static unsigned long
-ENTROPY_DEBUG(const char * label, unsigned long entropy) {
-  const char * const EXPAT_ENTROPY_DEBUG = getenv("EXPAT_ENTROPY_DEBUG");
+ENTROPY_DEBUG(const char *label, unsigned long entropy) {
+  const char *const EXPAT_ENTROPY_DEBUG = getenv("EXPAT_ENTROPY_DEBUG");
   if (EXPAT_ENTROPY_DEBUG && ! strcmp(EXPAT_ENTROPY_DEBUG, "1")) {
-    fprintf(stderr, "Entropy: %s --> 0x%0*lx (%lu bytes)\n",
-        label,
-        (int)sizeof(entropy) * 2, entropy,
-        (unsigned long)sizeof(entropy));
+    fprintf(stderr, "Entropy: %s --> 0x%0*lx (%lu bytes)\n", label,
+            (int)sizeof(entropy) * 2, entropy, (unsigned long)sizeof(entropy));
   }
   return entropy;
 }
 
 static unsigned long
-generate_hash_secret_salt(XML_Parser parser)
-{
+generate_hash_secret_salt(XML_Parser parser) {
   unsigned long entropy;
   (void)parser;
 
@@ -857,20 +813,20 @@ generate_hash_secret_salt(XML_Parser parser)
   return ENTROPY_DEBUG("arc4random", entropy);
 #else
   /* Try high quality providers first .. */
-#ifdef _WIN32
-  if (writeRandomBytes_RtlGenRandom((void *)&entropy, sizeof(entropy))) {
-    return ENTROPY_DEBUG("RtlGenRandom", entropy);
+#  ifdef _WIN32
+  if (writeRandomBytes_rand_s((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("rand_s", entropy);
   }
-#elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+#  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
   if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {
     return ENTROPY_DEBUG("getrandom", entropy);
   }
-#endif
-#if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+#  endif
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
   if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {
     return ENTROPY_DEBUG("/dev/urandom", entropy);
   }
-#endif  /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
   /* .. and self-made low quality for backup: */
 
   /* Process ID is 0 bits entropy if attacker has local access */
@@ -881,7 +837,7 @@ generate_hash_secret_salt(XML_Parser parser)
     return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
   } else {
     return ENTROPY_DEBUG("fallback(8)",
-        entropy * (unsigned long)2305843009213693951ULL);
+                         entropy * (unsigned long)2305843009213693951ULL);
   }
 #endif
 }
@@ -893,49 +849,43 @@ get_hash_secret_salt(XML_Parser parser) {
   return parser->m_hash_secret_salt;
 }
 
-static XML_Bool  /* only valid for root parser */
-startParsing(XML_Parser parser)
-{
-    /* hash functions must be initialized before setContext() is called */
-    if (parser->m_hash_secret_salt == 0)
-      parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
-    if (parser->m_ns) {
-      /* implicit context only set for root parser, since child
-         parsers (i.e. external entity parsers) will inherit it
-      */
-      return setContext(parser, implicitContext);
-    }
-    return XML_TRUE;
+static XML_Bool /* only valid for root parser */
+startParsing(XML_Parser parser) {
+  /* hash functions must be initialized before setContext() is called */
+  if (parser->m_hash_secret_salt == 0)
+    parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
+  if (parser->m_ns) {
+    /* implicit context only set for root parser, since child
+       parsers (i.e. external entity parsers) will inherit it
+    */
+    return setContext(parser, implicitContext);
+  }
+  return XML_TRUE;
 }
 
 XML_Parser XMLCALL
 XML_ParserCreate_MM(const XML_Char *encodingName,
                     const XML_Memory_Handling_Suite *memsuite,
-                    const XML_Char *nameSep)
-{
+                    const XML_Char *nameSep) {
   return parserCreate(encodingName, memsuite, nameSep, NULL);
 }
 
 static XML_Parser
 parserCreate(const XML_Char *encodingName,
-             const XML_Memory_Handling_Suite *memsuite,
-             const XML_Char *nameSep,
-             DTD *dtd)
-{
+             const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,
+             DTD *dtd) {
   XML_Parser parser;
 
   if (memsuite) {
     XML_Memory_Handling_Suite *mtemp;
-    parser = (XML_Parser)
-      memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
+    parser = (XML_Parser)memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
     if (parser != NULL) {
       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
       mtemp->malloc_fcn = memsuite->malloc_fcn;
       mtemp->realloc_fcn = memsuite->realloc_fcn;
       mtemp->free_fcn = memsuite->free_fcn;
     }
-  }
-  else {
+  } else {
     XML_Memory_Handling_Suite *mtemp;
     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
     if (parser != NULL) {
@@ -946,27 +896,30 @@ parserCreate(const XML_Char *encodingName,
     }
   }
 
-  if (!parser)
+  if (! parser)
     return parser;
 
   parser->m_buffer = NULL;
   parser->m_bufferLim = NULL;
 
   parser->m_attsSize = INIT_ATTS_SIZE;
-  parser->m_atts = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
+  parser->m_atts
+      = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
   if (parser->m_atts == NULL) {
     FREE(parser, parser);
     return NULL;
   }
 #ifdef XML_ATTR_INFO
-  parser->m_attInfo = (XML_AttrInfo*)MALLOC(parser, parser->m_attsSize * sizeof(XML_AttrInfo));
+  parser->m_attInfo = (XML_AttrInfo *)MALLOC(
+      parser, parser->m_attsSize * sizeof(XML_AttrInfo));
   if (parser->m_attInfo == NULL) {
     FREE(parser, parser->m_atts);
     FREE(parser, parser);
     return NULL;
   }
 #endif
-  parser->m_dataBuf = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
+  parser->m_dataBuf
+      = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
   if (parser->m_dataBuf == NULL) {
     FREE(parser, parser->m_atts);
 #ifdef XML_ATTR_INFO
@@ -1016,7 +969,7 @@ parserCreate(const XML_Char *encodingName,
   poolInit(&parser->m_temp2Pool, &(parser->m_mem));
   parserInit(parser, encodingName);
 
-  if (encodingName && !parser->m_protocolEncodingName) {
+  if (encodingName && ! parser->m_protocolEncodingName) {
     XML_ParserFree(parser);
     return NULL;
   }
@@ -1025,8 +978,7 @@ parserCreate(const XML_Char *encodingName,
     parser->m_ns = XML_TRUE;
     parser->m_internalEncoding = XmlGetInternalEncodingNS();
     parser->m_namespaceSeparator = *nameSep;
-  }
-  else {
+  } else {
     parser->m_internalEncoding = XmlGetInternalEncoding();
   }
 
@@ -1034,8 +986,7 @@ parserCreate(const XML_Char *encodingName,
 }
 
 static void
-parserInit(XML_Parser parser, const XML_Char *encodingName)
-{
+parserInit(XML_Parser parser, const XML_Char *encodingName) {
   parser->m_processor = prologInitProcessor;
   XmlPrologStateInit(&parser->m_prologState);
   if (encodingName != NULL) {
@@ -1108,8 +1059,7 @@ parserInit(XML_Parser parser, const XML_Char *encodingName)
 
 /* moves list of bindings to m_freeBindingList */
 static void FASTCALL
-moveToFreeBindingList(XML_Parser parser, BINDING *bindings)
-{
+moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
   while (bindings) {
     BINDING *b = bindings;
     bindings = bindings->nextTagBinding;
@@ -1119,13 +1069,12 @@ moveToFreeBindingList(XML_Parser parser, BINDING *bindings)
 }
 
 XML_Bool XMLCALL
-XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
-{
+XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
   TAG *tStk;
   OPEN_INTERNAL_ENTITY *openEntityList;
 
   if (parser == NULL)
-      return XML_FALSE;
+    return XML_FALSE;
 
   if (parser->m_parentParser)
     return XML_FALSE;
@@ -1161,15 +1110,15 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
 }
 
 enum XML_Status XMLCALL
-XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
-{
+XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
   if (parser == NULL)
-      return XML_STATUS_ERROR;
+    return XML_STATUS_ERROR;
   /* Block after XML_Parse()/XML_ParseBuffer() has been called.
      XXX There's no way for the caller to determine which of the
      XXX possible error cases caused the XML_STATUS_ERROR return.
   */
-  if (parser->m_parsingStatus.parsing == XML_PARSING || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
     return XML_STATUS_ERROR;
 
   /* Get rid of any previous encoding name */
@@ -1181,17 +1130,15 @@ XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
   else {
     /* Copy the new encoding name into allocated memory */
     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
-    if (!parser->m_protocolEncodingName)
+    if (! parser->m_protocolEncodingName)
       return XML_STATUS_ERROR;
   }
   return XML_STATUS_OK;
 }
 
 XML_Parser XMLCALL
-XML_ExternalEntityParserCreate(XML_Parser oldParser,
-                               const XML_Char *context,
-                               const XML_Char *encodingName)
-{
+XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,
+                               const XML_Char *encodingName) {
   XML_Parser parser = oldParser;
   DTD *newDtd = NULL;
   DTD *oldDtd;
@@ -1215,7 +1162,7 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
   XML_AttlistDeclHandler oldAttlistDeclHandler;
   XML_EntityDeclHandler oldEntityDeclHandler;
   XML_XmlDeclHandler oldXmlDeclHandler;
-  ELEMENT_TYPE * oldDeclElementType;
+  ELEMENT_TYPE *oldDeclElementType;
 
   void *oldUserData;
   void *oldHandlerArg;
@@ -1278,7 +1225,7 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
   oldhash_secret_salt = parser->m_hash_secret_salt;
 
 #ifdef XML_DTD
-  if (!context)
+  if (! context)
     newDtd = oldDtd;
 #endif /* XML_DTD */
 
@@ -1291,12 +1238,11 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
     XML_Char tmp[2];
     *tmp = parser->m_namespaceSeparator;
     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
-  }
-  else {
+  } else {
     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
   }
 
-  if (!parser)
+  if (! parser)
     return NULL;
 
   parser->m_startElementHandler = oldStartElementHandler;
@@ -1336,21 +1282,20 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
   parser->m_prologState.inEntityValue = oldInEntityValue;
   if (context) {
 #endif /* XML_DTD */
-    if (!dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
-      || !setContext(parser, context)) {
+    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
+        || ! setContext(parser, context)) {
       XML_ParserFree(parser);
       return NULL;
     }
     parser->m_processor = externalEntityInitProcessor;
 #ifdef XML_DTD
-  }
-  else {
-    /* The DTD instance referenced by parser->m_dtd is shared between the document's
-       root parser and external PE parsers, therefore one does not need to
-       call setContext. In addition, one also *must* not call setContext,
-       because this would overwrite existing prefix->binding pointers in
-       parser->m_dtd with ones that get destroyed with the external PE parser.
-       This would leave those prefixes with dangling pointers.
+  } else {
+    /* The DTD instance referenced by parser->m_dtd is shared between the
+       document's root parser and external PE parsers, therefore one does not
+       need to call setContext. In addition, one also *must* not call
+       setContext, because this would overwrite existing prefix->binding
+       pointers in parser->m_dtd with ones that get destroyed with the external
+       PE parser. This would leave those prefixes with dangling pointers.
     */
     parser->m_isParamEntity = XML_TRUE;
     XmlPrologStateInitExternalEntity(&parser->m_prologState);
@@ -1361,11 +1306,10 @@ XML_ExternalEntityParserCreate(XML_Parser oldParser,
 }
 
 static void FASTCALL
-destroyBindings(BINDING *bindings, XML_Parser parser)
-{
+destroyBindings(BINDING *bindings, XML_Parser parser) {
   for (;;) {
     BINDING *b = bindings;
-    if (!b)
+    if (! b)
       break;
     bindings = b->nextTagBinding;
     FREE(parser, b->uri);
@@ -1374,8 +1318,7 @@ destroyBindings(BINDING *bindings, XML_Parser parser)
 }
 
 void XMLCALL
-XML_ParserFree(XML_Parser parser)
-{
+XML_ParserFree(XML_Parser parser) {
   TAG *tagList;
   OPEN_INTERNAL_ENTITY *entityList;
   if (parser == NULL)
@@ -1420,11 +1363,12 @@ XML_ParserFree(XML_Parser parser)
   /* external parameter entity parsers share the DTD structure
      parser->m_dtd with the root parser, so we must not destroy it
   */
-  if (!parser->m_isParamEntity && parser->m_dtd)
+  if (! parser->m_isParamEntity && parser->m_dtd)
 #else
   if (parser->m_dtd)
 #endif /* XML_DTD */
-    dtdDestroy(parser->m_dtd, (XML_Bool)!parser->m_parentParser, &parser->m_mem);
+    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
+               &parser->m_mem);
   FREE(parser, (void *)parser->m_atts);
 #ifdef XML_ATTR_INFO
   FREE(parser, (void *)parser->m_attInfo);
@@ -1440,20 +1384,19 @@ XML_ParserFree(XML_Parser parser)
 }
 
 void XMLCALL
-XML_UseParserAsHandlerArg(XML_Parser parser)
-{
+XML_UseParserAsHandlerArg(XML_Parser parser) {
   if (parser != NULL)
     parser->m_handlerArg = parser;
 }
 
 enum XML_Error XMLCALL
-XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
-{
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
   if (parser == NULL)
     return XML_ERROR_INVALID_ARGUMENT;
 #ifdef XML_DTD
   /* block after XML_Parse()/XML_ParseBuffer() has been called */
-  if (parser->m_parsingStatus.parsing == XML_PARSING || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
     return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
   parser->m_useForeignDTD = useDTD;
   return XML_ERROR_NONE;
@@ -1463,19 +1406,18 @@ XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
 }
 
 void XMLCALL
-XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
-{
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
   if (parser == NULL)
     return;
   /* block after XML_Parse()/XML_ParseBuffer() has been called */
-  if (parser->m_parsingStatus.parsing == XML_PARSING || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
     return;
   parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
 }
 
 void XMLCALL
-XML_SetUserData(XML_Parser parser, void *p)
-{
+XML_SetUserData(XML_Parser parser, void *p) {
   if (parser == NULL)
     return;
   if (parser->m_handlerArg == parser->m_userData)
@@ -1485,49 +1427,43 @@ XML_SetUserData(XML_Parser parser, void *p)
 }
 
 enum XML_Status XMLCALL
-XML_SetBase(XML_Parser parser, const XML_Char *p)
-{
+XML_SetBase(XML_Parser parser, const XML_Char *p) {
   if (parser == NULL)
     return XML_STATUS_ERROR;
   if (p) {
     p = poolCopyString(&parser->m_dtd->pool, p);
-    if (!p)
+    if (! p)
       return XML_STATUS_ERROR;
     parser->m_curBase = p;
-  }
-  else
+  } else
     parser->m_curBase = NULL;
   return XML_STATUS_OK;
 }
 
-const XML_Char * XMLCALL
-XML_GetBase(XML_Parser parser)
-{
+const XML_Char *XMLCALL
+XML_GetBase(XML_Parser parser) {
   if (parser == NULL)
     return NULL;
   return parser->m_curBase;
 }
 
 int XMLCALL
-XML_GetSpecifiedAttributeCount(XML_Parser parser)
-{
+XML_GetSpecifiedAttributeCount(XML_Parser parser) {
   if (parser == NULL)
     return -1;
   return parser->m_nSpecifiedAtts;
 }
 
 int XMLCALL
-XML_GetIdAttributeIndex(XML_Parser parser)
-{
+XML_GetIdAttributeIndex(XML_Parser parser) {
   if (parser == NULL)
     return -1;
   return parser->m_idAttIndex;
 }
 
 #ifdef XML_ATTR_INFO
-const XML_AttrInfo * XMLCALL
-XML_GetAttributeInfo(XML_Parser parser)
-{
+const XML_AttrInfo *XMLCALL
+XML_GetAttributeInfo(XML_Parser parser) {
   if (parser == NULL)
     return NULL;
   return parser->m_attInfo;
@@ -1535,10 +1471,8 @@ XML_GetAttributeInfo(XML_Parser parser)
 #endif
 
 void XMLCALL
-XML_SetElementHandler(XML_Parser parser,
-                      XML_StartElementHandler start,
-                      XML_EndElementHandler end)
-{
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+                      XML_EndElementHandler end) {
   if (parser == NULL)
     return;
   parser->m_startElementHandler = start;
@@ -1546,39 +1480,33 @@ XML_SetElementHandler(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetStartElementHandler(XML_Parser parser,
-                           XML_StartElementHandler start) {
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
   if (parser != NULL)
     parser->m_startElementHandler = start;
 }
 
 void XMLCALL
-XML_SetEndElementHandler(XML_Parser parser,
-                         XML_EndElementHandler end) {
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
   if (parser != NULL)
     parser->m_endElementHandler = end;
 }
 
 void XMLCALL
 XML_SetCharacterDataHandler(XML_Parser parser,
-                            XML_CharacterDataHandler handler)
-{
+                            XML_CharacterDataHandler handler) {
   if (parser != NULL)
     parser->m_characterDataHandler = handler;
 }
 
 void XMLCALL
 XML_SetProcessingInstructionHandler(XML_Parser parser,
-                                    XML_ProcessingInstructionHandler handler)
-{
+                                    XML_ProcessingInstructionHandler handler) {
   if (parser != NULL)
     parser->m_processingInstructionHandler = handler;
 }
 
 void XMLCALL
-XML_SetCommentHandler(XML_Parser parser,
-                      XML_CommentHandler handler)
-{
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
   if (parser != NULL)
     parser->m_commentHandler = handler;
 }
@@ -1586,8 +1514,7 @@ XML_SetCommentHandler(XML_Parser parser,
 void XMLCALL
 XML_SetCdataSectionHandler(XML_Parser parser,
                            XML_StartCdataSectionHandler start,
-                           XML_EndCdataSectionHandler end)
-{
+                           XML_EndCdataSectionHandler end) {
   if (parser == NULL)
     return;
   parser->m_startCdataSectionHandler = start;
@@ -1609,9 +1536,7 @@ XML_SetEndCdataSectionHandler(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetDefaultHandler(XML_Parser parser,
-                      XML_DefaultHandler handler)
-{
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
   if (parser == NULL)
     return;
   parser->m_defaultHandler = handler;
@@ -1619,9 +1544,7 @@ XML_SetDefaultHandler(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetDefaultHandlerExpand(XML_Parser parser,
-                            XML_DefaultHandler handler)
-{
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
   if (parser == NULL)
     return;
   parser->m_defaultHandler = handler;
@@ -1629,10 +1552,8 @@ XML_SetDefaultHandlerExpand(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetDoctypeDeclHandler(XML_Parser parser,
-                          XML_StartDoctypeDeclHandler start,
-                          XML_EndDoctypeDeclHandler end)
-{
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+                          XML_EndDoctypeDeclHandler end) {
   if (parser == NULL)
     return;
   parser->m_startDoctypeDeclHandler = start;
@@ -1647,24 +1568,20 @@ XML_SetStartDoctypeDeclHandler(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetEndDoctypeDeclHandler(XML_Parser parser,
-                             XML_EndDoctypeDeclHandler end) {
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
   if (parser != NULL)
     parser->m_endDoctypeDeclHandler = end;
 }
 
 void XMLCALL
 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
-                                 XML_UnparsedEntityDeclHandler handler)
-{
+                                 XML_UnparsedEntityDeclHandler handler) {
   if (parser != NULL)
     parser->m_unparsedEntityDeclHandler = handler;
 }
 
 void XMLCALL
-XML_SetNotationDeclHandler(XML_Parser parser,
-                           XML_NotationDeclHandler handler)
-{
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
   if (parser != NULL)
     parser->m_notationDeclHandler = handler;
 }
@@ -1672,8 +1589,7 @@ XML_SetNotationDeclHandler(XML_Parser parser,
 void XMLCALL
 XML_SetNamespaceDeclHandler(XML_Parser parser,
                             XML_StartNamespaceDeclHandler start,
-                            XML_EndNamespaceDeclHandler end)
-{
+                            XML_EndNamespaceDeclHandler end) {
   if (parser == NULL)
     return;
   parser->m_startNamespaceDeclHandler = start;
@@ -1696,23 +1612,20 @@ XML_SetEndNamespaceDeclHandler(XML_Parser parser,
 
 void XMLCALL
 XML_SetNotStandaloneHandler(XML_Parser parser,
-                            XML_NotStandaloneHandler handler)
-{
+                            XML_NotStandaloneHandler handler) {
   if (parser != NULL)
     parser->m_notStandaloneHandler = handler;
 }
 
 void XMLCALL
 XML_SetExternalEntityRefHandler(XML_Parser parser,
-                                XML_ExternalEntityRefHandler handler)
-{
+                                XML_ExternalEntityRefHandler handler) {
   if (parser != NULL)
     parser->m_externalEntityRefHandler = handler;
 }
 
 void XMLCALL
-XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
-{
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
   if (parser == NULL)
     return;
   if (arg)
@@ -1723,17 +1636,14 @@ XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
 
 void XMLCALL
 XML_SetSkippedEntityHandler(XML_Parser parser,
-                            XML_SkippedEntityHandler handler)
-{
+                            XML_SkippedEntityHandler handler) {
   if (parser != NULL)
     parser->m_skippedEntityHandler = handler;
 }
 
 void XMLCALL
 XML_SetUnknownEncodingHandler(XML_Parser parser,
-                              XML_UnknownEncodingHandler handler,
-                              void *data)
-{
+                              XML_UnknownEncodingHandler handler, void *data) {
   if (parser == NULL)
     return;
   parser->m_unknownEncodingHandler = handler;
@@ -1741,44 +1651,37 @@ XML_SetUnknownEncodingHandler(XML_Parser parser,
 }
 
 void XMLCALL
-XML_SetElementDeclHandler(XML_Parser parser,
-                          XML_ElementDeclHandler eldecl)
-{
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
   if (parser != NULL)
     parser->m_elementDeclHandler = eldecl;
 }
 
 void XMLCALL
-XML_SetAttlistDeclHandler(XML_Parser parser,
-                          XML_AttlistDeclHandler attdecl)
-{
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
   if (parser != NULL)
     parser->m_attlistDeclHandler = attdecl;
 }
 
 void XMLCALL
-XML_SetEntityDeclHandler(XML_Parser parser,
-                         XML_EntityDeclHandler handler)
-{
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
   if (parser != NULL)
     parser->m_entityDeclHandler = handler;
 }
 
 void XMLCALL
-XML_SetXmlDeclHandler(XML_Parser parser,
-                      XML_XmlDeclHandler handler) {
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
   if (parser != NULL)
     parser->m_xmlDeclHandler = handler;
 }
 
 int XMLCALL
 XML_SetParamEntityParsing(XML_Parser parser,
-                          enum XML_ParamEntityParsing peParsing)
-{
+                          enum XML_ParamEntityParsing peParsing) {
   if (parser == NULL)
     return 0;
   /* block after XML_Parse()/XML_ParseBuffer() has been called */
-  if (parser->m_parsingStatus.parsing == XML_PARSING || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
     return 0;
 #ifdef XML_DTD
   parser->m_paramEntityParsing = peParsing;
@@ -1789,23 +1692,21 @@ XML_SetParamEntityParsing(XML_Parser parser,
 }
 
 int XMLCALL
-XML_SetHashSalt(XML_Parser parser,
-                unsigned long hash_salt)
-{
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
   if (parser == NULL)
     return 0;
   if (parser->m_parentParser)
     return XML_SetHashSalt(parser->m_parentParser, hash_salt);
   /* block after XML_Parse()/XML_ParseBuffer() has been called */
-  if (parser->m_parsingStatus.parsing == XML_PARSING || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
     return 0;
   parser->m_hash_secret_salt = hash_salt;
   return 1;
 }
 
 enum XML_Status XMLCALL
-XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
-{
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
   if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
     if (parser != NULL)
       parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
@@ -1819,7 +1720,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
     parser->m_errorCode = XML_ERROR_FINISHED;
     return XML_STATUS_ERROR;
   case XML_INITIALIZED:
-    if (parser->m_parentParser == NULL && !startParsing(parser)) {
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
       parser->m_errorCode = XML_ERROR_NO_MEMORY;
       return XML_STATUS_ERROR;
     }
@@ -1830,7 +1731,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
 
   if (len == 0) {
     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
-    if (!isFinal)
+    if (! isFinal)
       return XML_STATUS_OK;
     parser->m_positionPtr = parser->m_bufferPtr;
     parser->m_parseEndPtr = parser->m_bufferEnd;
@@ -1839,7 +1740,9 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
        data are the final chunk of input, then we have to check them again
        to detect errors based on that fact.
     */
-    parser->m_errorCode = parser->m_processor(parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
+    parser->m_errorCode
+        = parser->m_processor(parser, parser->m_bufferPtr,
+                              parser->m_parseEndPtr, &parser->m_bufferPtr);
 
     if (parser->m_errorCode == XML_ERROR_NONE) {
       switch (parser->m_parsingStatus.parsing) {
@@ -1856,7 +1759,8 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
          *
          * LCOV_EXCL_START
          */
-        XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, parser->m_bufferPtr, &parser->m_position);
+        XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                          parser->m_bufferPtr, &parser->m_position);
         parser->m_positionPtr = parser->m_bufferPtr;
         return XML_STATUS_SUSPENDED;
         /* LCOV_EXCL_STOP */
@@ -1879,23 +1783,23 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
     enum XML_Status result;
     /* Detect overflow (a+b > MAX <==> b > MAX-a) */
     if (len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
-       parser->m_errorCode = XML_ERROR_NO_MEMORY;
-       parser->m_eventPtr = parser->m_eventEndPtr = NULL;
-       parser->m_processor = errorProcessor;
-       return XML_STATUS_ERROR;
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+      parser->m_processor = errorProcessor;
+      return XML_STATUS_ERROR;
     }
     parser->m_parseEndByteIndex += len;
     parser->m_positionPtr = s;
     parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
 
-    parser->m_errorCode = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
+    parser->m_errorCode
+        = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
 
     if (parser->m_errorCode != XML_ERROR_NONE) {
       parser->m_eventEndPtr = parser->m_eventPtr;
       parser->m_processor = errorProcessor;
       return XML_STATUS_ERROR;
-    }
-    else {
+    } else {
       switch (parser->m_parsingStatus.parsing) {
       case XML_SUSPENDED:
         result = XML_STATUS_SUSPENDED;
@@ -1912,10 +1816,12 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
       }
     }
 
-    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end, &parser->m_position);
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
+                      &parser->m_position);
     nLeftOver = s + len - end;
     if (nLeftOver) {
-      if (parser->m_buffer == NULL || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
+      if (parser->m_buffer == NULL
+          || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
         /* avoid _signed_ integer overflow */
         char *temp = NULL;
         const int bytesToAllocate = (int)((unsigned)len * 2U);
@@ -1941,7 +1847,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
     parser->m_eventEndPtr = parser->m_bufferPtr;
     return result;
   }
-#endif  /* not defined XML_CONTEXT_BYTES */
+#endif /* not defined XML_CONTEXT_BYTES */
   else {
     void *buff = XML_GetBuffer(parser, len);
     if (buff == NULL)
@@ -1954,8 +1860,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
 }
 
 enum XML_Status XMLCALL
-XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
-{
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
   const char *start;
   enum XML_Status result = XML_STATUS_OK;
 
@@ -1969,7 +1874,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
     parser->m_errorCode = XML_ERROR_FINISHED;
     return XML_STATUS_ERROR;
   case XML_INITIALIZED:
-    if (parser->m_parentParser == NULL && !startParsing(parser)) {
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
       parser->m_errorCode = XML_ERROR_NO_MEMORY;
       return XML_STATUS_ERROR;
     }
@@ -1985,14 +1890,14 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
   parser->m_parseEndByteIndex += len;
   parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
 
-  parser->m_errorCode = parser->m_processor(parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
+  parser->m_errorCode = parser->m_processor(
+      parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
 
   if (parser->m_errorCode != XML_ERROR_NONE) {
     parser->m_eventEndPtr = parser->m_eventPtr;
     parser->m_processor = errorProcessor;
     return XML_STATUS_ERROR;
-  }
-  else {
+  } else {
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       result = XML_STATUS_SUSPENDED;
@@ -2003,18 +1908,18 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
         parser->m_parsingStatus.parsing = XML_FINISHED;
         return result;
       }
-    default: ;  /* should not happen */
+    default:; /* should not happen */
     }
   }
 
-  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, parser->m_bufferPtr, &parser->m_position);
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
   parser->m_positionPtr = parser->m_bufferPtr;
   return result;
 }
 
-void * XMLCALL
-XML_GetBuffer(XML_Parser parser, int len)
-{
+void *XMLCALL
+XML_GetBuffer(XML_Parser parser, int len) {
   if (parser == NULL)
     return NULL;
   if (len < 0) {
@@ -2028,17 +1933,17 @@ XML_GetBuffer(XML_Parser parser, int len)
   case XML_FINISHED:
     parser->m_errorCode = XML_ERROR_FINISHED;
     return NULL;
-  default: ;
+  default:;
   }
 
   if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
 #ifdef XML_CONTEXT_BYTES
     int keep;
-#endif  /* defined XML_CONTEXT_BYTES */
+#endif /* defined XML_CONTEXT_BYTES */
     /* Do not invoke signed arithmetic overflow: */
-    int neededSize = (int) ((unsigned)len +
-                            (unsigned)EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd,
-                                                          parser->m_bufferPtr));
+    int neededSize = (int)((unsigned)len
+                           + (unsigned)EXPAT_SAFE_PTR_DIFF(
+                               parser->m_bufferEnd, parser->m_bufferPtr));
     if (neededSize < 0) {
       parser->m_errorCode = XML_ERROR_NO_MEMORY;
       return NULL;
@@ -2048,13 +1953,18 @@ XML_GetBuffer(XML_Parser parser, int len)
     if (keep > XML_CONTEXT_BYTES)
       keep = XML_CONTEXT_BYTES;
     neededSize += keep;
-#endif  /* defined XML_CONTEXT_BYTES */
-    if (neededSize <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
+#endif /* defined XML_CONTEXT_BYTES */
+    if (neededSize
+        <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
 #ifdef XML_CONTEXT_BYTES
       if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
-          int offset = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer) - keep;
-        /* The buffer pointers cannot be NULL here; we have at least some bytes in the buffer */
-        memmove(parser->m_buffer, &parser->m_buffer[offset], parser->m_bufferEnd - parser->m_bufferPtr + keep);
+        int offset
+            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
+              - keep;
+        /* The buffer pointers cannot be NULL here; we have at least some bytes
+         * in the buffer */
+        memmove(parser->m_buffer, &parser->m_buffer[offset],
+                parser->m_bufferEnd - parser->m_bufferPtr + keep);
         parser->m_bufferEnd -= offset;
         parser->m_bufferPtr -= offset;
       }
@@ -2062,20 +1972,21 @@ XML_GetBuffer(XML_Parser parser, int len)
       if (parser->m_buffer && parser->m_bufferPtr) {
         memmove(parser->m_buffer, parser->m_bufferPtr,
                 EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
-        parser->m_bufferEnd = parser->m_buffer +
-            EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+        parser->m_bufferEnd
+            = parser->m_buffer
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
         parser->m_bufferPtr = parser->m_buffer;
       }
-#endif  /* not defined XML_CONTEXT_BYTES */
-    }
-    else {
+#endif /* not defined XML_CONTEXT_BYTES */
+    } else {
       char *newBuf;
-      int bufferSize = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
+      int bufferSize
+          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
       if (bufferSize == 0)
         bufferSize = INIT_BUFFER_SIZE;
       do {
         /* Do not invoke signed arithmetic overflow: */
-        bufferSize = (int) (2U * (unsigned) bufferSize);
+        bufferSize = (int)(2U * (unsigned)bufferSize);
       } while (bufferSize < neededSize && bufferSize > 0);
       if (bufferSize <= 0) {
         parser->m_errorCode = XML_ERROR_NO_MEMORY;
@@ -2089,18 +2000,17 @@ XML_GetBuffer(XML_Parser parser, int len)
       parser->m_bufferLim = newBuf + bufferSize;
 #ifdef XML_CONTEXT_BYTES
       if (parser->m_bufferPtr) {
-        int keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
-        if (keep > XML_CONTEXT_BYTES)
-          keep = XML_CONTEXT_BYTES;
         memcpy(newBuf, &parser->m_bufferPtr[-keep],
-               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr) + keep);
+               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+                   + keep);
         FREE(parser, parser->m_buffer);
         parser->m_buffer = newBuf;
-        parser->m_bufferEnd = parser->m_buffer +
-            EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr) + keep;
+        parser->m_bufferEnd
+            = parser->m_buffer
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+              + keep;
         parser->m_bufferPtr = parser->m_buffer + keep;
-      }
-      else {
+      } else {
         /* This must be a brand new buffer with no data in it yet */
         parser->m_bufferEnd = newBuf;
         parser->m_bufferPtr = parser->m_buffer = newBuf;
@@ -2110,15 +2020,15 @@ XML_GetBuffer(XML_Parser parser, int len)
         memcpy(newBuf, parser->m_bufferPtr,
                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
         FREE(parser, parser->m_buffer);
-        parser->m_bufferEnd = newBuf +
-            EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
-      }
-      else {
+        parser->m_bufferEnd
+            = newBuf
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+      } else {
         /* This must be a brand new buffer with no data in it yet */
         parser->m_bufferEnd = newBuf;
       }
       parser->m_bufferPtr = parser->m_buffer = newBuf;
-#endif  /* not defined XML_CONTEXT_BYTES */
+#endif /* not defined XML_CONTEXT_BYTES */
     }
     parser->m_eventPtr = parser->m_eventEndPtr = NULL;
     parser->m_positionPtr = NULL;
@@ -2127,8 +2037,7 @@ XML_GetBuffer(XML_Parser parser, int len)
 }
 
 enum XML_Status XMLCALL
-XML_StopParser(XML_Parser parser, XML_Bool resumable)
-{
+XML_StopParser(XML_Parser parser, XML_Bool resumable) {
   if (parser == NULL)
     return XML_STATUS_ERROR;
   switch (parser->m_parsingStatus.parsing) {
@@ -2151,16 +2060,14 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable)
       }
 #endif
       parser->m_parsingStatus.parsing = XML_SUSPENDED;
-    }
-    else
+    } else
       parser->m_parsingStatus.parsing = XML_FINISHED;
   }
   return XML_STATUS_OK;
 }
 
 enum XML_Status XMLCALL
-XML_ResumeParser(XML_Parser parser)
-{
+XML_ResumeParser(XML_Parser parser) {
   enum XML_Status result = XML_STATUS_OK;
 
   if (parser == NULL)
@@ -2171,14 +2078,14 @@ XML_ResumeParser(XML_Parser parser)
   }
   parser->m_parsingStatus.parsing = XML_PARSING;
 
-  parser->m_errorCode = parser->m_processor(parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
+  parser->m_errorCode = parser->m_processor(
+      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
 
   if (parser->m_errorCode != XML_ERROR_NONE) {
     parser->m_eventEndPtr = parser->m_eventPtr;
     parser->m_processor = errorProcessor;
     return XML_STATUS_ERROR;
-  }
-  else {
+  } else {
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       result = XML_STATUS_SUSPENDED;
@@ -2189,18 +2096,18 @@ XML_ResumeParser(XML_Parser parser)
         parser->m_parsingStatus.parsing = XML_FINISHED;
         return result;
       }
-    default: ;
+    default:;
     }
   }
 
-  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, parser->m_bufferPtr, &parser->m_position);
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
   parser->m_positionPtr = parser->m_bufferPtr;
   return result;
 }
 
 void XMLCALL
-XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)
-{
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
   if (parser == NULL)
     return;
   assert(status != NULL);
@@ -2208,26 +2115,24 @@ XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)
 }
 
 enum XML_Error XMLCALL
-XML_GetErrorCode(XML_Parser parser)
-{
+XML_GetErrorCode(XML_Parser parser) {
   if (parser == NULL)
     return XML_ERROR_INVALID_ARGUMENT;
   return parser->m_errorCode;
 }
 
 XML_Index XMLCALL
-XML_GetCurrentByteIndex(XML_Parser parser)
-{
+XML_GetCurrentByteIndex(XML_Parser parser) {
   if (parser == NULL)
     return -1;
   if (parser->m_eventPtr)
-    return (XML_Index)(parser->m_parseEndByteIndex - (parser->m_parseEndPtr - parser->m_eventPtr));
+    return (XML_Index)(parser->m_parseEndByteIndex
+                       - (parser->m_parseEndPtr - parser->m_eventPtr));
   return -1;
 }
 
 int XMLCALL
-XML_GetCurrentByteCount(XML_Parser parser)
-{
+XML_GetCurrentByteCount(XML_Parser parser) {
   if (parser == NULL)
     return 0;
   if (parser->m_eventEndPtr && parser->m_eventPtr)
@@ -2235,9 +2140,8 @@ XML_GetCurrentByteCount(XML_Parser parser)
   return 0;
 }
 
-const char * XMLCALL
-XML_GetInputContext(XML_Parser parser, int *offset, int *size)
-{
+const char *XMLCALL
+XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
 #ifdef XML_CONTEXT_BYTES
   if (parser == NULL)
     return NULL;
@@ -2245,7 +2149,7 @@ XML_GetInputContext(XML_Parser parser, int *offset, int *size)
     if (offset != NULL)
       *offset = (int)(parser->m_eventPtr - parser->m_buffer);
     if (size != NULL)
-      *size   = (int)(parser->m_bufferEnd - parser->m_buffer);
+      *size = (int)(parser->m_bufferEnd - parser->m_buffer);
     return parser->m_buffer;
   }
 #else
@@ -2253,82 +2157,76 @@ XML_GetInputContext(XML_Parser parser, int *offset, int *size)
   (void)offset;
   (void)size;
 #endif /* defined XML_CONTEXT_BYTES */
-  return (char *) 0;
+  return (char *)0;
 }
 
 XML_Size XMLCALL
-XML_GetCurrentLineNumber(XML_Parser parser)
-{
+XML_GetCurrentLineNumber(XML_Parser parser) {
   if (parser == NULL)
     return 0;
   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
-    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, parser->m_eventPtr, &parser->m_position);
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
     parser->m_positionPtr = parser->m_eventPtr;
   }
   return parser->m_position.lineNumber + 1;
 }
 
 XML_Size XMLCALL
-XML_GetCurrentColumnNumber(XML_Parser parser)
-{
+XML_GetCurrentColumnNumber(XML_Parser parser) {
   if (parser == NULL)
     return 0;
   if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
-    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, parser->m_eventPtr, &parser->m_position);
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
     parser->m_positionPtr = parser->m_eventPtr;
   }
   return parser->m_position.columnNumber;
 }
 
 void XMLCALL
-XML_FreeContentModel(XML_Parser parser, XML_Content *model)
-{
+XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
   if (parser != NULL)
     FREE(parser, model);
 }
 
-void * XMLCALL
-XML_MemMalloc(XML_Parser parser, size_t size)
-{
+void *XMLCALL
+XML_MemMalloc(XML_Parser parser, size_t size) {
   if (parser == NULL)
     return NULL;
   return MALLOC(parser, size);
 }
 
-void * XMLCALL
-XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)
-{
+void *XMLCALL
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
   if (parser == NULL)
     return NULL;
   return REALLOC(parser, ptr, size);
 }
 
 void XMLCALL
-XML_MemFree(XML_Parser parser, void *ptr)
-{
+XML_MemFree(XML_Parser parser, void *ptr) {
   if (parser != NULL)
     FREE(parser, ptr);
 }
 
 void XMLCALL
-XML_DefaultCurrent(XML_Parser parser)
-{
+XML_DefaultCurrent(XML_Parser parser) {
   if (parser == NULL)
     return;
   if (parser->m_defaultHandler) {
     if (parser->m_openInternalEntities)
-      reportDefault(parser,
-                    parser->m_internalEncoding,
+      reportDefault(parser, parser->m_internalEncoding,
                     parser->m_openInternalEntities->internalEventPtr,
                     parser->m_openInternalEntities->internalEventEndPtr);
     else
-      reportDefault(parser, parser->m_encoding, parser->m_eventPtr, parser->m_eventEndPtr);
+      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
+                    parser->m_eventEndPtr);
   }
 }
 
-const XML_LChar * XMLCALL
-XML_ErrorString(enum XML_Error code)
-{
+const XML_LChar *XMLCALL
+XML_ErrorString(enum XML_Error code) {
   switch (code) {
   case XML_ERROR_NONE:
     return NULL;
@@ -2410,21 +2308,22 @@ XML_ErrorString(enum XML_Error code)
     return XML_L("cannot suspend in external parameter entity");
   /* Added in 2.0.0. */
   case XML_ERROR_RESERVED_PREFIX_XML:
-    return XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name");
+    return XML_L(
+        "reserved prefix (xml) must not be undeclared or bound to another namespace name");
   case XML_ERROR_RESERVED_PREFIX_XMLNS:
     return XML_L("reserved prefix (xmlns) must not be declared or undeclared");
   case XML_ERROR_RESERVED_NAMESPACE_URI:
-    return XML_L("prefix must not be bound to one of the reserved namespace names");
+    return XML_L(
+        "prefix must not be bound to one of the reserved namespace names");
   /* Added in 2.2.5. */
-  case XML_ERROR_INVALID_ARGUMENT:  /* Constant added in 2.2.1, already */
+  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
     return XML_L("invalid argument");
   }
   return NULL;
 }
 
-const XML_LChar * XMLCALL
+const XML_LChar *XMLCALL
 XML_ExpatVersion(void) {
-
   /* V1 is used to string-ize the version number. However, it would
      string-ize the actual version macro *names* unless we get them
      substituted before being passed to V1. CPP is defined to expand
@@ -2433,8 +2332,8 @@ XML_ExpatVersion(void) {
      with the correct numerals. */
   /* ### I'm assuming cpp is portable in this respect... */
 
-#define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)
-#define V2(a,b,c) XML_L("expat_")V1(a,b,c)
+#define V1(a, b, c) XML_L(#a) XML_L(".") XML_L(#b) XML_L(".") XML_L(#c)
+#define V2(a, b, c) XML_L("expat_") V1(a, b, c)
 
   return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
 
@@ -2443,8 +2342,7 @@ XML_ExpatVersion(void) {
 }
 
 XML_Expat_Version XMLCALL
-XML_ExpatVersionInfo(void)
-{
+XML_ExpatVersionInfo(void) {
   XML_Expat_Version version;
 
   version.major = XML_MAJOR_VERSION;
@@ -2454,41 +2352,39 @@ XML_ExpatVersionInfo(void)
   return version;
 }
 
-const XML_Feature * XMLCALL
-XML_GetFeatureList(void)
-{
-  static const XML_Feature features[] = {
-    {XML_FEATURE_SIZEOF_XML_CHAR,  XML_L("sizeof(XML_Char)"),
-     sizeof(XML_Char)},
-    {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
-     sizeof(XML_LChar)},
+const XML_Feature *XMLCALL
+XML_GetFeatureList(void) {
+  static const XML_Feature features[]
+      = {{XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
+          sizeof(XML_Char)},
+         {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
+          sizeof(XML_LChar)},
 #ifdef XML_UNICODE
-    {XML_FEATURE_UNICODE,          XML_L("XML_UNICODE"), 0},
+         {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
 #endif
 #ifdef XML_UNICODE_WCHAR_T
-    {XML_FEATURE_UNICODE_WCHAR_T,  XML_L("XML_UNICODE_WCHAR_T"), 0},
+         {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},
 #endif
 #ifdef XML_DTD
-    {XML_FEATURE_DTD,              XML_L("XML_DTD"), 0},
+         {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},
 #endif
 #ifdef XML_CONTEXT_BYTES
-    {XML_FEATURE_CONTEXT_BYTES,    XML_L("XML_CONTEXT_BYTES"),
-     XML_CONTEXT_BYTES},
+         {XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),
+          XML_CONTEXT_BYTES},
 #endif
 #ifdef XML_MIN_SIZE
-    {XML_FEATURE_MIN_SIZE,         XML_L("XML_MIN_SIZE"), 0},
+         {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
 #endif
 #ifdef XML_NS
-    {XML_FEATURE_NS,               XML_L("XML_NS"), 0},
+         {XML_FEATURE_NS, XML_L("XML_NS"), 0},
 #endif
 #ifdef XML_LARGE_SIZE
-    {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
+         {XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
 #endif
 #ifdef XML_ATTR_INFO
-    {XML_FEATURE_ATTR_INFO,        XML_L("XML_ATTR_INFO"), 0},
+         {XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
 #endif
-    {XML_FEATURE_END,              NULL, 0}
-  };
+         {XML_FEATURE_END, NULL, 0}};
 
   return features;
 }
@@ -2499,8 +2395,7 @@ XML_GetFeatureList(void)
    permanent location, since the parse buffer is about to be discarded.
 */
 static XML_Bool
-storeRawNames(XML_Parser parser)
-{
+storeRawNames(XML_Parser parser) {
   TAG *tag = parser->m_tagStack;
   while (tag) {
     int bufSize;
@@ -2530,8 +2425,8 @@ storeRawNames(XML_Parser parser)
          then update it as well, since it will always point into tag->buf
       */
       if (tag->name.localPart)
-        tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -
-                                                  (XML_Char *)tag->buf);
+        tag->name.localPart
+            = (XML_Char *)temp + (tag->name.localPart - (XML_Char *)tag->buf);
       tag->buf = temp;
       tag->bufEnd = temp + bufSize;
       rawNameBuf = temp + nameLen;
@@ -2544,26 +2439,21 @@ storeRawNames(XML_Parser parser)
 }
 
 static enum XML_Error PTRCALL
-contentProcessor(XML_Parser parser,
-                 const char *start,
-                 const char *end,
-                 const char **endPtr)
-{
-  enum XML_Error result = doContent(parser, 0, parser->m_encoding, start, end,
-                                    endPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+contentProcessor(XML_Parser parser, const char *start, const char *end,
+                 const char **endPtr) {
+  enum XML_Error result
+      = doContent(parser, 0, parser->m_encoding, start, end, endPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer);
   if (result == XML_ERROR_NONE) {
-    if (!storeRawNames(parser))
+    if (! storeRawNames(parser))
       return XML_ERROR_NO_MEMORY;
   }
   return result;
 }
 
 static enum XML_Error PTRCALL
-externalEntityInitProcessor(XML_Parser parser,
-                            const char *start,
-                            const char *end,
-                            const char **endPtr)
-{
+externalEntityInitProcessor(XML_Parser parser, const char *start,
+                            const char *end, const char **endPtr) {
   enum XML_Error result = initializeEncoding(parser);
   if (result != XML_ERROR_NONE)
     return result;
@@ -2572,11 +2462,8 @@ externalEntityInitProcessor(XML_Parser parser,
 }
 
 static enum XML_Error PTRCALL
-externalEntityInitProcessor2(XML_Parser parser,
-                             const char *start,
-                             const char *end,
-                             const char **endPtr)
-{
+externalEntityInitProcessor2(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
   const char *next = start; /* XmlContentTok doesn't always set the last arg */
   int tok = XmlContentTok(parser->m_encoding, start, end, &next);
   switch (tok) {
@@ -2586,21 +2473,21 @@ externalEntityInitProcessor2(XML_Parser parser,
        doContent (by detecting XML_TOK_NONE) without processing any xml text
        declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
     */
-    if (next == end && !parser->m_parsingStatus.finalBuffer) {
+    if (next == end && ! parser->m_parsingStatus.finalBuffer) {
       *endPtr = next;
       return XML_ERROR_NONE;
     }
     start = next;
     break;
   case XML_TOK_PARTIAL:
-    if (!parser->m_parsingStatus.finalBuffer) {
+    if (! parser->m_parsingStatus.finalBuffer) {
       *endPtr = start;
       return XML_ERROR_NONE;
     }
     parser->m_eventPtr = start;
     return XML_ERROR_UNCLOSED_TOKEN;
   case XML_TOK_PARTIAL_CHAR:
-    if (!parser->m_parsingStatus.finalBuffer) {
+    if (! parser->m_parsingStatus.finalBuffer) {
       *endPtr = start;
       return XML_ERROR_NONE;
     }
@@ -2612,11 +2499,8 @@ externalEntityInitProcessor2(XML_Parser parser,
 }
 
 static enum XML_Error PTRCALL
-externalEntityInitProcessor3(XML_Parser parser,
-                             const char *start,
-                             const char *end,
-                             const char **endPtr)
-{
+externalEntityInitProcessor3(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
   int tok;
   const char *next = start; /* XmlContentTok doesn't always set the last arg */
   parser->m_eventPtr = start;
@@ -2624,31 +2508,29 @@ externalEntityInitProcessor3(XML_Parser parser,
   parser->m_eventEndPtr = next;
 
   switch (tok) {
-  case XML_TOK_XML_DECL:
-    {
-      enum XML_Error result;
-      result = processXmlDecl(parser, 1, start, next);
-      if (result != XML_ERROR_NONE)
-        return result;
-      switch (parser->m_parsingStatus.parsing) {
-      case XML_SUSPENDED:
-        *endPtr = next;
-        return XML_ERROR_NONE;
-      case XML_FINISHED:
-        return XML_ERROR_ABORTED;
-      default:
-        start = next;
-      }
+  case XML_TOK_XML_DECL: {
+    enum XML_Error result;
+    result = processXmlDecl(parser, 1, start, next);
+    if (result != XML_ERROR_NONE)
+      return result;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *endPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:
+      start = next;
     }
-    break;
+  } break;
   case XML_TOK_PARTIAL:
-    if (!parser->m_parsingStatus.finalBuffer) {
+    if (! parser->m_parsingStatus.finalBuffer) {
       *endPtr = start;
       return XML_ERROR_NONE;
     }
     return XML_ERROR_UNCLOSED_TOKEN;
   case XML_TOK_PARTIAL_CHAR:
-    if (!parser->m_parsingStatus.finalBuffer) {
+    if (! parser->m_parsingStatus.finalBuffer) {
       *endPtr = start;
       return XML_ERROR_NONE;
     }
@@ -2660,39 +2542,31 @@ externalEntityInitProcessor3(XML_Parser parser,
 }
 
 static enum XML_Error PTRCALL
-externalEntityContentProcessor(XML_Parser parser,
-                               const char *start,
-                               const char *end,
-                               const char **endPtr)
-{
-  enum XML_Error result = doContent(parser, 1, parser->m_encoding, start, end,
-                                    endPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+externalEntityContentProcessor(XML_Parser parser, const char *start,
+                               const char *end, const char **endPtr) {
+  enum XML_Error result
+      = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer);
   if (result == XML_ERROR_NONE) {
-    if (!storeRawNames(parser))
+    if (! storeRawNames(parser))
       return XML_ERROR_NO_MEMORY;
   }
   return result;
 }
 
 static enum XML_Error
-doContent(XML_Parser parser,
-          int startTagLevel,
-          const ENCODING *enc,
-          const char *s,
-          const char *end,
-          const char **nextPtr,
-          XML_Bool haveMore)
-{
+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
+          const char *s, const char *end, const char **nextPtr,
+          XML_Bool haveMore) {
   /* save one level of indirection */
-  DTD * const dtd = parser->m_dtd;
+  DTD *const dtd = parser->m_dtd;
 
   const char **eventPP;
   const char **eventEndPP;
   if (enc == parser->m_encoding) {
     eventPP = &parser->m_eventPtr;
     eventEndPP = &parser->m_eventEndPtr;
-  }
-  else {
+  } else {
     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
   }
@@ -2712,8 +2586,7 @@ doContent(XML_Parser parser,
       if (parser->m_characterDataHandler) {
         XML_Char c = 0xA;
         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
-      }
-      else if (parser->m_defaultHandler)
+      } else if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, end);
       /* We are at the end of the final buffer, should we check for
          XML_SUSPENDED, XML_FINISHED?
@@ -2751,185 +2624,178 @@ doContent(XML_Parser parser,
         return XML_ERROR_NONE;
       }
       return XML_ERROR_PARTIAL_CHAR;
-    case XML_TOK_ENTITY_REF:
-      {
-        const XML_Char *name;
-        ENTITY *entity;
-        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
-                                              s + enc->minBytesPerChar,
-                                              next - enc->minBytesPerChar);
-        if (ch) {
-          if (parser->m_characterDataHandler)
-            parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
-          else if (parser->m_defaultHandler)
-            reportDefault(parser, enc, s, next);
-          break;
-        }
-        name = poolStoreString(&dtd->pool, enc,
-                                s + enc->minBytesPerChar,
-                                next - enc->minBytesPerChar);
-        if (!name)
-          return XML_ERROR_NO_MEMORY;
-        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
-        poolDiscard(&dtd->pool);
-        /* First, determine if a check for an existing declaration is needed;
-           if yes, check that the entity exists, and that it is internal,
-           otherwise call the skipped entity or default handler.
-        */
-        if (!dtd->hasParamEntityRefs || dtd->standalone) {
-          if (!entity)
-            return XML_ERROR_UNDEFINED_ENTITY;
-          else if (!entity->is_internal)
-            return XML_ERROR_ENTITY_DECLARED_IN_PE;
-        }
-        else if (!entity) {
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+        if (parser->m_characterDataHandler)
+          parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&dtd->pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal,
+         otherwise call the skipped entity or default handler.
+      */
+      if (! dtd->hasParamEntityRefs || dtd->standalone) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      if (entity->open)
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
+      if (entity->notation)
+        return XML_ERROR_BINARY_ENTITY_REF;
+      if (entity->textPtr) {
+        enum XML_Error result;
+        if (! parser->m_defaultExpandInternalEntities) {
           if (parser->m_skippedEntityHandler)
-            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+            parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
+                                           0);
           else if (parser->m_defaultHandler)
             reportDefault(parser, enc, s, next);
           break;
         }
-        if (entity->open)
-          return XML_ERROR_RECURSIVE_ENTITY_REF;
-        if (entity->notation)
-          return XML_ERROR_BINARY_ENTITY_REF;
-        if (entity->textPtr) {
-          enum XML_Error result;
-          if (!parser->m_defaultExpandInternalEntities) {
-            if (parser->m_skippedEntityHandler)
-              parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name, 0);
-            else if (parser->m_defaultHandler)
-              reportDefault(parser, enc, s, next);
-            break;
-          }
-          result = processInternalEntity(parser, entity, XML_FALSE);
-          if (result != XML_ERROR_NONE)
-            return result;
-        }
-        else if (parser->m_externalEntityRefHandler) {
-          const XML_Char *context;
-          entity->open = XML_TRUE;
-          context = getContext(parser);
-          entity->open = XML_FALSE;
-          if (!context)
-            return XML_ERROR_NO_MEMORY;
-          if (!parser->m_externalEntityRefHandler(parser->m_externalEntityRefHandlerArg,
-                                        context,
-                                        entity->base,
-                                        entity->systemId,
-                                        entity->publicId))
-            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
-          poolDiscard(&parser->m_tempPool);
-        }
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-        break;
-      }
+        result = processInternalEntity(parser, entity, XML_FALSE);
+        if (result != XML_ERROR_NONE)
+          return result;
+      } else if (parser->m_externalEntityRefHandler) {
+        const XML_Char *context;
+        entity->open = XML_TRUE;
+        context = getContext(parser);
+        entity->open = XML_FALSE;
+        if (! context)
+          return XML_ERROR_NO_MEMORY;
+        if (! parser->m_externalEntityRefHandler(
+                parser->m_externalEntityRefHandlerArg, context, entity->base,
+                entity->systemId, entity->publicId))
+          return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+        poolDiscard(&parser->m_tempPool);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    }
     case XML_TOK_START_TAG_NO_ATTS:
       /* fall through */
-    case XML_TOK_START_TAG_WITH_ATTS:
-      {
-        TAG *tag;
-        enum XML_Error result;
-        XML_Char *toPtr;
-        if (parser->m_freeTagList) {
-          tag = parser->m_freeTagList;
-          parser->m_freeTagList = parser->m_freeTagList->parent;
+    case XML_TOK_START_TAG_WITH_ATTS: {
+      TAG *tag;
+      enum XML_Error result;
+      XML_Char *toPtr;
+      if (parser->m_freeTagList) {
+        tag = parser->m_freeTagList;
+        parser->m_freeTagList = parser->m_freeTagList->parent;
+      } else {
+        tag = (TAG *)MALLOC(parser, sizeof(TAG));
+        if (! tag)
+          return XML_ERROR_NO_MEMORY;
+        tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
+        if (! tag->buf) {
+          FREE(parser, tag);
+          return XML_ERROR_NO_MEMORY;
         }
-        else {
-          tag = (TAG *)MALLOC(parser, sizeof(TAG));
-          if (!tag)
-            return XML_ERROR_NO_MEMORY;
-          tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
-          if (!tag->buf) {
-            FREE(parser, tag);
-            return XML_ERROR_NO_MEMORY;
+        tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
+      }
+      tag->bindings = NULL;
+      tag->parent = parser->m_tagStack;
+      parser->m_tagStack = tag;
+      tag->name.localPart = NULL;
+      tag->name.prefix = NULL;
+      tag->rawName = s + enc->minBytesPerChar;
+      tag->rawNameLength = XmlNameLength(enc, tag->rawName);
+      ++parser->m_tagLevel;
+      {
+        const char *rawNameEnd = tag->rawName + tag->rawNameLength;
+        const char *fromPtr = tag->rawName;
+        toPtr = (XML_Char *)tag->buf;
+        for (;;) {
+          int bufSize;
+          int convLen;
+          const enum XML_Convert_Result convert_res
+              = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,
+                           (ICHAR *)tag->bufEnd - 1);
+          convLen = (int)(toPtr - (XML_Char *)tag->buf);
+          if ((fromPtr >= rawNameEnd)
+              || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
+            tag->name.strLen = convLen;
+            break;
           }
-          tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
-        }
-        tag->bindings = NULL;
-        tag->parent = parser->m_tagStack;
-        parser->m_tagStack = tag;
-        tag->name.localPart = NULL;
-        tag->name.prefix = NULL;
-        tag->rawName = s + enc->minBytesPerChar;
-        tag->rawNameLength = XmlNameLength(enc, tag->rawName);
-        ++parser->m_tagLevel;
-        {
-          const char *rawNameEnd = tag->rawName + tag->rawNameLength;
-          const char *fromPtr = tag->rawName;
-          toPtr = (XML_Char *)tag->buf;
-          for (;;) {
-            int bufSize;
-            int convLen;
-            const enum XML_Convert_Result convert_res = XmlConvert(enc,
-                       &fromPtr, rawNameEnd,
-                       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
-            convLen = (int)(toPtr - (XML_Char *)tag->buf);
-            if ((fromPtr >= rawNameEnd) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
-              tag->name.strLen = convLen;
-              break;
-            }
-            bufSize = (int)(tag->bufEnd - tag->buf) << 1;
-            {
-              char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
-              if (temp == NULL)
-                return XML_ERROR_NO_MEMORY;
-              tag->buf = temp;
-              tag->bufEnd = temp + bufSize;
-              toPtr = (XML_Char *)temp + convLen;
-            }
+          bufSize = (int)(tag->bufEnd - tag->buf) << 1;
+          {
+            char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
+            if (temp == NULL)
+              return XML_ERROR_NO_MEMORY;
+            tag->buf = temp;
+            tag->bufEnd = temp + bufSize;
+            toPtr = (XML_Char *)temp + convLen;
           }
         }
-        tag->name.str = (XML_Char *)tag->buf;
-        *toPtr = XML_T('\0');
-        result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
-        if (result)
-          return result;
-        if (parser->m_startElementHandler)
-          parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
-                              (const XML_Char **)parser->m_atts);
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-        poolClear(&parser->m_tempPool);
-        break;
       }
+      tag->name.str = (XML_Char *)tag->buf;
+      *toPtr = XML_T('\0');
+      result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
+      if (result)
+        return result;
+      if (parser->m_startElementHandler)
+        parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
+                                      (const XML_Char **)parser->m_atts);
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      break;
+    }
     case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
       /* fall through */
-    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
-      {
-        const char *rawName = s + enc->minBytesPerChar;
-        enum XML_Error result;
-        BINDING *bindings = NULL;
-        XML_Bool noElmHandlers = XML_TRUE;
-        TAG_NAME name;
-        name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
-                                   rawName + XmlNameLength(enc, rawName));
-        if (!name.str)
-          return XML_ERROR_NO_MEMORY;
-        poolFinish(&parser->m_tempPool);
-        result = storeAtts(parser, enc, s, &name, &bindings);
-        if (result != XML_ERROR_NONE) {
-          freeBindings(parser, bindings);
-          return result;
-        }
-        poolFinish(&parser->m_tempPool);
-        if (parser->m_startElementHandler) {
-          parser->m_startElementHandler(parser->m_handlerArg, name.str, (const XML_Char **)parser->m_atts);
-          noElmHandlers = XML_FALSE;
-        }
-        if (parser->m_endElementHandler) {
-          if (parser->m_startElementHandler)
-            *eventPP = *eventEndPP;
-          parser->m_endElementHandler(parser->m_handlerArg, name.str);
-          noElmHandlers = XML_FALSE;
-        }
-        if (noElmHandlers && parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-        poolClear(&parser->m_tempPool);
+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {
+      const char *rawName = s + enc->minBytesPerChar;
+      enum XML_Error result;
+      BINDING *bindings = NULL;
+      XML_Bool noElmHandlers = XML_TRUE;
+      TAG_NAME name;
+      name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
+                                 rawName + XmlNameLength(enc, rawName));
+      if (! name.str)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_tempPool);
+      result = storeAtts(parser, enc, s, &name, &bindings);
+      if (result != XML_ERROR_NONE) {
         freeBindings(parser, bindings);
+        return result;
+      }
+      poolFinish(&parser->m_tempPool);
+      if (parser->m_startElementHandler) {
+        parser->m_startElementHandler(parser->m_handlerArg, name.str,
+                                      (const XML_Char **)parser->m_atts);
+        noElmHandlers = XML_FALSE;
+      }
+      if (parser->m_endElementHandler) {
+        if (parser->m_startElementHandler)
+          *eventPP = *eventEndPP;
+        parser->m_endElementHandler(parser->m_handlerArg, name.str);
+        noElmHandlers = XML_FALSE;
       }
-      if ((parser->m_tagLevel == 0) && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+      if (noElmHandlers && parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      freeBindings(parser, bindings);
+    }
+      if ((parser->m_tagLevel == 0)
+          && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
         if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
           parser->m_processor = epilogProcessor;
         else
@@ -2946,7 +2812,7 @@ doContent(XML_Parser parser,
         parser->m_tagStack = tag->parent;
         tag->parent = parser->m_freeTagList;
         parser->m_freeTagList = tag;
-        rawName = s + enc->minBytesPerChar*2;
+        rawName = s + enc->minBytesPerChar * 2;
         len = XmlNameLength(enc, rawName);
         if (len != tag->rawNameLength
             || memcmp(tag->rawName, rawName, len) != 0) {
@@ -2966,86 +2832,89 @@ doContent(XML_Parser parser,
             */
             uri = (XML_Char *)tag->name.str + tag->name.uriLen;
             /* don't need to check for space - already done in storeAtts() */
-            while (*localPart) *uri++ = *localPart++;
+            while (*localPart)
+              *uri++ = *localPart++;
             prefix = (XML_Char *)tag->name.prefix;
             if (parser->m_ns_triplets && prefix) {
               *uri++ = parser->m_namespaceSeparator;
-              while (*prefix) *uri++ = *prefix++;
-             }
+              while (*prefix)
+                *uri++ = *prefix++;
+            }
             *uri = XML_T('\0');
           }
           parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
-        }
-        else if (parser->m_defaultHandler)
+        } else if (parser->m_defaultHandler)
           reportDefault(parser, enc, s, next);
         while (tag->bindings) {
           BINDING *b = tag->bindings;
           if (parser->m_endNamespaceDeclHandler)
-            parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
+            parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
+                                              b->prefix->name);
           tag->bindings = tag->bindings->nextTagBinding;
           b->nextTagBinding = parser->m_freeBindingList;
           parser->m_freeBindingList = b;
           b->prefix->binding = b->prevPrefixBinding;
         }
-        if (parser->m_tagLevel == 0)
-          return epilogProcessor(parser, next, end, nextPtr);
-      }
-      break;
-    case XML_TOK_CHAR_REF:
-      {
-        int n = XmlCharRefNumber(enc, s);
-        if (n < 0)
-          return XML_ERROR_BAD_CHAR_REF;
-        if (parser->m_characterDataHandler) {
-          XML_Char buf[XML_ENCODE_MAX];
-          parser->m_characterDataHandler(parser->m_handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
+        if ((parser->m_tagLevel == 0)
+            && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+          if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
+            parser->m_processor = epilogProcessor;
+          else
+            return epilogProcessor(parser, next, end, nextPtr);
         }
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
       }
       break;
+    case XML_TOK_CHAR_REF: {
+      int n = XmlCharRefNumber(enc, s);
+      if (n < 0)
+        return XML_ERROR_BAD_CHAR_REF;
+      if (parser->m_characterDataHandler) {
+        XML_Char buf[XML_ENCODE_MAX];
+        parser->m_characterDataHandler(parser->m_handlerArg, buf,
+                                       XmlEncode(n, (ICHAR *)buf));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
     case XML_TOK_XML_DECL:
       return XML_ERROR_MISPLACED_XML_PI;
     case XML_TOK_DATA_NEWLINE:
       if (parser->m_characterDataHandler) {
         XML_Char c = 0xA;
         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
-      }
-      else if (parser->m_defaultHandler)
+      } else if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, next);
       break;
-    case XML_TOK_CDATA_SECT_OPEN:
-      {
-        enum XML_Error result;
-        if (parser->m_startCdataSectionHandler)
-          parser->m_startCdataSectionHandler(parser->m_handlerArg);
-#if 0
-        /* Suppose you doing a transformation on a document that involves
-           changing only the character data.  You set up a defaultHandler
-           and a characterDataHandler.  The defaultHandler simply copies
-           characters through.  The characterDataHandler does the
-           transformation and writes the characters out escaping them as
-           necessary.  This case will fail to work if we leave out the
-           following two lines (because & and < inside CDATA sections will
-           be incorrectly escaped).
-
-           However, now we have a start/endCdataSectionHandler, so it seems
-           easier to let the user deal with this.
-        */
-        else if (parser->m_characterDataHandler)
-          parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf, 0);
-#endif
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-        result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
-        if (result != XML_ERROR_NONE)
-          return result;
-        else if (!next) {
-          parser->m_processor = cdataSectionProcessor;
-          return result;
-        }
+    case XML_TOK_CDATA_SECT_OPEN: {
+      enum XML_Error result;
+      if (parser->m_startCdataSectionHandler)
+        parser->m_startCdataSectionHandler(parser->m_handlerArg);
+      /* BEGIN disabled code */
+      /* Suppose you doing a transformation on a document that involves
+         changing only the character data.  You set up a defaultHandler
+         and a characterDataHandler.  The defaultHandler simply copies
+         characters through.  The characterDataHandler does the
+         transformation and writes the characters out escaping them as
+         necessary.  This case will fail to work if we leave out the
+         following two lines (because & and < inside CDATA sections will
+         be incorrectly escaped).
+
+         However, now we have a start/endCdataSectionHandler, so it seems
+         easier to let the user deal with this.
+      */
+      else if (0 && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = cdataSectionProcessor;
+        return result;
       }
-      break;
+    } break;
     case XML_TOK_TRAILING_RSQB:
       if (haveMore) {
         *nextPtr = s;
@@ -3055,15 +2924,14 @@ doContent(XML_Parser parser,
         if (MUST_CONVERT(enc, s)) {
           ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
-          parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
-                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
-        }
-        else
-          parser->m_characterDataHandler(parser->m_handlerArg,
-                               (XML_Char *)s,
-                               (int)((XML_Char *)end - (XML_Char *)s));
-      }
-      else if (parser->m_defaultHandler)
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, parser->m_dataBuf,
+              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+        } else
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, (XML_Char *)s,
+              (int)((XML_Char *)end - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, end);
       /* We are at the end of the final buffer, should we check for
          XML_SUSPENDED, XML_FINISHED?
@@ -3078,37 +2946,34 @@ doContent(XML_Parser parser,
       }
       *nextPtr = end;
       return XML_ERROR_NONE;
-    case XML_TOK_DATA_CHARS:
-      {
-        XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
-        if (charDataHandler) {
-          if (MUST_CONVERT(enc, s)) {
-            for (;;) {
-              ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
-              const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
-              *eventEndPP = s;
-              charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
-                              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
-              if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
-                break;
-              *eventPP = s;
-            }
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = s;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
           }
-          else
-            charDataHandler(parser->m_handlerArg,
-                            (XML_Char *)s,
-                            (int)((XML_Char *)next - (XML_Char *)s));
-        }
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-      }
-      break;
+        } else
+          charDataHandler(parser->m_handlerArg, (XML_Char *)s,
+                          (int)((XML_Char *)next - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
     case XML_TOK_PI:
-      if (!reportProcessingInstruction(parser, enc, s, next))
+      if (! reportProcessingInstruction(parser, enc, s, next))
         return XML_ERROR_NO_MEMORY;
       break;
     case XML_TOK_COMMENT:
-      if (!reportComment(parser, enc, s, next))
+      if (! reportComment(parser, enc, s, next))
         return XML_ERROR_NO_MEMORY;
       break;
     default:
@@ -3131,7 +2996,7 @@ doContent(XML_Parser parser,
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
-    default: ;
+    default:;
     }
   }
   /* not reached */
@@ -3142,8 +3007,7 @@ doContent(XML_Parser parser,
  * reused as appropriate.
  */
 static void
-freeBindings(XML_Parser parser, BINDING *bindings)
-{
+freeBindings(XML_Parser parser, BINDING *bindings) {
   while (bindings) {
     BINDING *b = bindings;
 
@@ -3151,7 +3015,7 @@ freeBindings(XML_Parser parser, BINDING *bindings)
      * binding in addBindings(), so call the end handler now.
      */
     if (parser->m_endNamespaceDeclHandler)
-        parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
+      parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
 
     bindings = bindings->nextTagBinding;
     b->nextTagBinding = parser->m_freeBindingList;
@@ -3171,14 +3035,12 @@ freeBindings(XML_Parser parser, BINDING *bindings)
    - generate namespace aware element name (URI, prefix)
 */
 static enum XML_Error
-storeAtts(XML_Parser parser, const ENCODING *enc,
-          const char *attStr, TAG_NAME *tagNamePtr,
-          BINDING **bindingsPtr)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
+          TAG_NAME *tagNamePtr, BINDING **bindingsPtr) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   ELEMENT_TYPE *elementType;
   int nDefaultAtts;
-  const XML_Char **appAtts;   /* the attribute list for the application */
+  const XML_Char **appAtts; /* the attribute list for the application */
   int attIndex = 0;
   int prefixLen;
   int i;
@@ -3189,16 +3051,17 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
   const XML_Char *localPart;
 
   /* lookup the element type name */
-  elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0);
-  if (!elementType) {
+  elementType
+      = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
+  if (! elementType) {
     const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
-    if (!name)
+    if (! name)
       return XML_ERROR_NO_MEMORY;
     elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
                                          sizeof(ELEMENT_TYPE));
-    if (!elementType)
+    if (! elementType)
       return XML_ERROR_NO_MEMORY;
-    if (parser->m_ns && !setElementTypePrefix(parser, elementType))
+    if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
       return XML_ERROR_NO_MEMORY;
   }
   nDefaultAtts = elementType->nDefaultAtts;
@@ -3212,14 +3075,16 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
     XML_AttrInfo *temp2;
 #endif
     parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
-    temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts, parser->m_attsSize * sizeof(ATTRIBUTE));
+    temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
+                                parser->m_attsSize * sizeof(ATTRIBUTE));
     if (temp == NULL) {
       parser->m_attsSize = oldAttsSize;
       return XML_ERROR_NO_MEMORY;
     }
     parser->m_atts = temp;
 #ifdef XML_ATTR_INFO
-    temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo, parser->m_attsSize * sizeof(XML_AttrInfo));
+    temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
+                                    parser->m_attsSize * sizeof(XML_AttrInfo));
     if (temp2 == NULL) {
       parser->m_attsSize = oldAttsSize;
       return XML_ERROR_NO_MEMORY;
@@ -3237,18 +3102,20 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
     XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
 #endif
     /* add the name and value to the attribute list */
-    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, currAtt->name,
-                                         currAtt->name
-                                         + XmlNameLength(enc, currAtt->name));
-    if (!attId)
+    ATTRIBUTE_ID *attId
+        = getAttributeId(parser, enc, currAtt->name,
+                         currAtt->name + XmlNameLength(enc, currAtt->name));
+    if (! attId)
       return XML_ERROR_NO_MEMORY;
 #ifdef XML_ATTR_INFO
-    currAttInfo->nameStart = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
-    currAttInfo->nameEnd = currAttInfo->nameStart +
-                           XmlNameLength(enc, currAtt->name);
-    currAttInfo->valueStart = parser->m_parseEndByteIndex -
-                            (parser->m_parseEndPtr - currAtt->valuePtr);
-    currAttInfo->valueEnd = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->valueEnd);
+    currAttInfo->nameStart
+        = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
+    currAttInfo->nameEnd
+        = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);
+    currAttInfo->valueStart = parser->m_parseEndByteIndex
+                              - (parser->m_parseEndPtr - currAtt->valuePtr);
+    currAttInfo->valueEnd = parser->m_parseEndByteIndex
+                            - (parser->m_parseEndPtr - currAtt->valueEnd);
 #endif
     /* Detect duplicate attributes by their QNames. This does not work when
        namespace processing is turned on and different prefixes for the same
@@ -3261,7 +3128,7 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
     }
     (attId->name)[-1] = 1;
     appAtts[attIndex++] = attId->name;
-    if (!parser->m_atts[i].normalized) {
+    if (! parser->m_atts[i].normalized) {
       enum XML_Error result;
       XML_Bool isCdata = XML_TRUE;
 
@@ -3277,17 +3144,17 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
       }
 
       /* normalize the attribute value */
-      result = storeAttributeValue(parser, enc, isCdata,
-                                   parser->m_atts[i].valuePtr, parser->m_atts[i].valueEnd,
-                                   &parser->m_tempPool);
+      result = storeAttributeValue(
+          parser, enc, isCdata, parser->m_atts[i].valuePtr,
+          parser->m_atts[i].valueEnd, &parser->m_tempPool);
       if (result)
         return result;
       appAtts[attIndex] = poolStart(&parser->m_tempPool);
       poolFinish(&parser->m_tempPool);
-    }
-    else {
+    } else {
       /* the value did not need normalizing */
-      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc, parser->m_atts[i].valuePtr,
+      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
+                                          parser->m_atts[i].valuePtr,
                                           parser->m_atts[i].valueEnd);
       if (appAtts[attIndex] == 0)
         return XML_ERROR_NO_MEMORY;
@@ -3302,15 +3169,13 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
         if (result)
           return result;
         --attIndex;
-      }
-      else {
+      } else {
         /* deal with other prefixed names later */
         attIndex++;
         nPrefixes++;
         (attId->name)[-1] = 2;
       }
-    }
-    else
+    } else
       attIndex++;
   }
 
@@ -3322,29 +3187,26 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
         parser->m_idAttIndex = i;
         break;
       }
-  }
-  else
+  } else
     parser->m_idAttIndex = -1;
 
   /* do attribute defaulting */
   for (i = 0; i < nDefaultAtts; i++) {
     const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
-    if (!(da->id->name)[-1] && da->value) {
+    if (! (da->id->name)[-1] && da->value) {
       if (da->id->prefix) {
         if (da->id->xmlns) {
           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
                                              da->value, bindingsPtr);
           if (result)
             return result;
-        }
-        else {
+        } else {
           (da->id->name)[-1] = 2;
           nPrefixes++;
           appAtts[attIndex++] = da->id->name;
           appAtts[attIndex++] = da->value;
         }
-      }
-      else {
+      } else {
         (da->id->name)[-1] = 1;
         appAtts[attIndex++] = da->id->name;
         appAtts[attIndex++] = da->value;
@@ -3357,31 +3219,34 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
      and clear flags that say whether attributes were specified */
   i = 0;
   if (nPrefixes) {
-    int j;  /* hash table index */
+    int j; /* hash table index */
     unsigned long version = parser->m_nsAttsVersion;
     int nsAttsSize = (int)1 << parser->m_nsAttsPower;
     unsigned char oldNsAttsPower = parser->m_nsAttsPower;
     /* size of hash table must be at least 2 * (# of prefixed attributes) */
-    if ((nPrefixes << 1) >> parser->m_nsAttsPower) {  /* true for m_nsAttsPower = 0 */
+    if ((nPrefixes << 1)
+        >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
       NS_ATT *temp;
       /* hash table size must also be a power of 2 and >= 8 */
-      while (nPrefixes >> parser->m_nsAttsPower++);
+      while (nPrefixes >> parser->m_nsAttsPower++)
+        ;
       if (parser->m_nsAttsPower < 3)
         parser->m_nsAttsPower = 3;
       nsAttsSize = (int)1 << parser->m_nsAttsPower;
-      temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts, nsAttsSize * sizeof(NS_ATT));
-      if (!temp) {
+      temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
+                               nsAttsSize * sizeof(NS_ATT));
+      if (! temp) {
         /* Restore actual size of memory in m_nsAtts */
         parser->m_nsAttsPower = oldNsAttsPower;
         return XML_ERROR_NO_MEMORY;
       }
       parser->m_nsAtts = temp;
-      version = 0;  /* force re-initialization of m_nsAtts hash table */
+      version = 0; /* force re-initialization of m_nsAtts hash table */
     }
     /* using a version flag saves us from initializing m_nsAtts every time */
-    if (!version) {  /* initialize version flags when version wraps around */
+    if (! version) { /* initialize version flags when version wraps around */
       version = INIT_ATTS_VERSION;
-      for (j = nsAttsSize; j != 0; )
+      for (j = nsAttsSize; j != 0;)
         parser->m_nsAtts[--j].version = version;
     }
     parser->m_nsAttsVersion = --version;
@@ -3389,7 +3254,7 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
     /* expand prefixed names and check for duplicates */
     for (; i < attIndex; i += 2) {
       const XML_Char *s = appAtts[i];
-      if (s[-1] == 2) {  /* prefixed */
+      if (s[-1] == 2) { /* prefixed */
         ATTRIBUTE_ID *id;
         const BINDING *b;
         unsigned long uriHash;
@@ -3399,9 +3264,9 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
         copy_salt_to_sipkey(parser, &sip_key);
         sip24_init(&sip_state, &sip_key);
 
-        ((XML_Char *)s)[-1] = 0;  /* clear flag */
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
         id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
-        if (!id || !id->prefix) {
+        if (! id || ! id->prefix) {
           /* This code is walking through the appAtts array, dealing
            * with (in this case) a prefixed attribute name.  To be in
            * the array, the attribute must have already been bound, so
@@ -3419,12 +3284,12 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
           return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
         }
         b = id->prefix->binding;
-        if (!b)
+        if (! b)
           return XML_ERROR_UNBOUND_PREFIX;
 
         for (j = 0; j < b->uriLen; j++) {
           const XML_Char c = b->uri[j];
-          if (!poolAppendChar(&parser->m_tempPool, c))
+          if (! poolAppendChar(&parser->m_tempPool, c))
             return XML_ERROR_NO_MEMORY;
         }
 
@@ -3435,8 +3300,8 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
 
         sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
 
-        do {  /* copies null terminator */
-          if (!poolAppendChar(&parser->m_tempPool, *s))
+        do { /* copies null terminator */
+          if (! poolAppendChar(&parser->m_tempPool, *s))
             return XML_ERROR_NO_MEMORY;
         } while (*s++);
 
@@ -3447,28 +3312,29 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
           */
           unsigned char step = 0;
           unsigned long mask = nsAttsSize - 1;
-          j = uriHash & mask;  /* index into hash table */
+          j = uriHash & mask; /* index into hash table */
           while (parser->m_nsAtts[j].version == version) {
             /* for speed we compare stored hash values first */
             if (uriHash == parser->m_nsAtts[j].hash) {
               const XML_Char *s1 = poolStart(&parser->m_tempPool);
               const XML_Char *s2 = parser->m_nsAtts[j].uriName;
               /* s1 is null terminated, but not s2 */
-              for (; *s1 == *s2 && *s1 != 0; s1++, s2++);
+              for (; *s1 == *s2 && *s1 != 0; s1++, s2++)
+                ;
               if (*s1 == 0)
                 return XML_ERROR_DUPLICATE_ATTRIBUTE;
             }
-            if (!step)
+            if (! step)
               step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
             j < step ? (j += nsAttsSize - step) : (j -= step);
           }
         }
 
-        if (parser->m_ns_triplets) {  /* append namespace separator and prefix */
+        if (parser->m_ns_triplets) { /* append namespace separator and prefix */
           parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
           s = b->prefix->name;
           do {
-            if (!poolAppendChar(&parser->m_tempPool, *s))
+            if (! poolAppendChar(&parser->m_tempPool, *s))
               return XML_ERROR_NO_MEMORY;
           } while (*s++);
         }
@@ -3483,13 +3349,12 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
         parser->m_nsAtts[j].hash = uriHash;
         parser->m_nsAtts[j].uriName = s;
 
-        if (!--nPrefixes) {
+        if (! --nPrefixes) {
           i += 2;
           break;
         }
-      }
-      else  /* not prefixed */
-        ((XML_Char *)s)[-1] = 0;  /* clear flag */
+      } else                     /* not prefixed */
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
     }
   }
   /* clear flags for the remaining attributes */
@@ -3498,40 +3363,38 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
   for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
     binding->attId->name[-1] = 0;
 
-  if (!parser->m_ns)
+  if (! parser->m_ns)
     return XML_ERROR_NONE;
 
   /* expand the element type name */
   if (elementType->prefix) {
     binding = elementType->prefix->binding;
-    if (!binding)
+    if (! binding)
       return XML_ERROR_UNBOUND_PREFIX;
     localPart = tagNamePtr->str;
     while (*localPart++ != XML_T(ASCII_COLON))
       ;
-  }
-  else if (dtd->defaultPrefix.binding) {
+  } else if (dtd->defaultPrefix.binding) {
     binding = dtd->defaultPrefix.binding;
     localPart = tagNamePtr->str;
-  }
-  else
+  } else
     return XML_ERROR_NONE;
   prefixLen = 0;
   if (parser->m_ns_triplets && binding->prefix->name) {
     for (; binding->prefix->name[prefixLen++];)
-      ;  /* prefixLen includes null terminator */
+      ; /* prefixLen includes null terminator */
   }
   tagNamePtr->localPart = localPart;
   tagNamePtr->uriLen = binding->uriLen;
   tagNamePtr->prefix = binding->prefix->name;
   tagNamePtr->prefixLen = prefixLen;
   for (i = 0; localPart[i++];)
-    ;  /* i includes null terminator */
+    ; /* i includes null terminator */
   n = i + binding->uriLen + prefixLen;
   if (n > binding->uriAlloc) {
     TAG *p;
     uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
-    if (!uri)
+    if (! uri)
       return XML_ERROR_NO_MEMORY;
     binding->uriAlloc = n + EXPAND_SPARE;
     memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
@@ -3547,7 +3410,7 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
   /* we always have a namespace separator between localPart and prefix */
   if (prefixLen) {
     uri += i - 1;
-    *uri = parser->m_namespaceSeparator;  /* replace null terminator */
+    *uri = parser->m_namespaceSeparator; /* replace null terminator */
     memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
   }
   tagNamePtr->str = binding->uri;
@@ -3559,27 +3422,25 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
 */
 static enum XML_Error
 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
-           const XML_Char *uri, BINDING **bindingsPtr)
-{
-  static const XML_Char xmlNamespace[] = {
-    ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
-    ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
-    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
-    ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
-    ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
-    ASCII_e, '\0'
-  };
-  static const int xmlLen =
-    (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
-  static const XML_Char xmlnsNamespace[] = {
-    ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
-    ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
-    ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
-    ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
-    ASCII_SLASH, '\0'
-  };
-  static const int xmlnsLen =
-    (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
+           const XML_Char *uri, BINDING **bindingsPtr) {
+  static const XML_Char xmlNamespace[]
+      = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,
+         ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,
+         ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,
+         ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,
+         ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,
+         ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,
+         ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,
+         ASCII_e,      '\0'};
+  static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;
+  static const XML_Char xmlnsNamespace[]
+      = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,
+         ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,
+         ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,
+         ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,
+         ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\0'};
+  static const int xmlnsLen
+      = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;
 
   XML_Bool mustBeXML = XML_FALSE;
   XML_Bool isXML = XML_TRUE;
@@ -3592,14 +3453,11 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
   if (*uri == XML_T('\0') && prefix->name)
     return XML_ERROR_UNDECLARING_PREFIX;
 
-  if (prefix->name
-      && prefix->name[0] == XML_T(ASCII_x)
+  if (prefix->name && prefix->name[0] == XML_T(ASCII_x)
       && prefix->name[1] == XML_T(ASCII_m)
       && prefix->name[2] == XML_T(ASCII_l)) {
-
     /* Not allowed to bind xmlns */
-    if (prefix->name[3] == XML_T(ASCII_n)
-        && prefix->name[4] == XML_T(ASCII_s)
+    if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)
         && prefix->name[5] == XML_T('\0'))
       return XML_ERROR_RESERVED_PREFIX_XMLNS;
 
@@ -3611,7 +3469,7 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
     if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
       isXML = XML_FALSE;
 
-    if (!mustBeXML && isXMLNS
+    if (! mustBeXML && isXMLNS
         && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
       isXMLNS = XML_FALSE;
   }
@@ -3630,21 +3488,21 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
   if (parser->m_freeBindingList) {
     b = parser->m_freeBindingList;
     if (len > b->uriAlloc) {
-      XML_Char *temp = (XML_Char *)REALLOC(parser, b->uri,
-                          sizeof(XML_Char) * (len + EXPAND_SPARE));
+      XML_Char *temp = (XML_Char *)REALLOC(
+          parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
       if (temp == NULL)
         return XML_ERROR_NO_MEMORY;
       b->uri = temp;
       b->uriAlloc = len + EXPAND_SPARE;
     }
     parser->m_freeBindingList = b->nextTagBinding;
-  }
-  else {
+  } else {
     b = (BINDING *)MALLOC(parser, sizeof(BINDING));
-    if (!b)
+    if (! b)
       return XML_ERROR_NO_MEMORY;
-    b->uri = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
-    if (!b->uri) {
+    b->uri
+        = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
+    if (! b->uri) {
       FREE(parser, b);
       return XML_ERROR_NO_MEMORY;
     }
@@ -3667,7 +3525,7 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
   /* if attId == NULL then we are not starting a namespace scope */
   if (attId && parser->m_startNamespaceDeclHandler)
     parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
-                              prefix->binding ? uri : 0);
+                                        prefix->binding ? uri : 0);
   return XML_ERROR_NONE;
 }
 
@@ -3675,21 +3533,18 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
    the whole file is parsed with one call.
 */
 static enum XML_Error PTRCALL
-cdataSectionProcessor(XML_Parser parser,
-                      const char *start,
-                      const char *end,
-                      const char **endPtr)
-{
-  enum XML_Error result = doCdataSection(parser, parser->m_encoding, &start, end,
-                                         endPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                      const char **endPtr) {
+  enum XML_Error result
+      = doCdataSection(parser, parser->m_encoding, &start, end, endPtr,
+                       (XML_Bool)! parser->m_parsingStatus.finalBuffer);
   if (result != XML_ERROR_NONE)
     return result;
   if (start) {
-    if (parser->m_parentParser) {  /* we are parsing an external entity */
+    if (parser->m_parentParser) { /* we are parsing an external entity */
       parser->m_processor = externalEntityContentProcessor;
       return externalEntityContentProcessor(parser, start, end, endPtr);
-    }
-    else {
+    } else {
       parser->m_processor = contentProcessor;
       return contentProcessor(parser, start, end, endPtr);
     }
@@ -3701,13 +3556,8 @@ cdataSectionProcessor(XML_Parser parser,
    the section is not yet closed.
 */
 static enum XML_Error
-doCdataSection(XML_Parser parser,
-               const ENCODING *enc,
-               const char **startPtr,
-               const char *end,
-               const char **nextPtr,
-               XML_Bool haveMore)
-{
+doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+               const char *end, const char **nextPtr, XML_Bool haveMore) {
   const char *s = *startPtr;
   const char **eventPP;
   const char **eventEndPP;
@@ -3715,8 +3565,7 @@ doCdataSection(XML_Parser parser,
     eventPP = &parser->m_eventPtr;
     *eventPP = s;
     eventEndPP = &parser->m_eventEndPtr;
-  }
-  else {
+  } else {
     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
   }
@@ -3731,11 +3580,12 @@ doCdataSection(XML_Parser parser,
     case XML_TOK_CDATA_SECT_CLOSE:
       if (parser->m_endCdataSectionHandler)
         parser->m_endCdataSectionHandler(parser->m_handlerArg);
-#if 0
+      /* BEGIN disabled code */
       /* see comment under XML_TOK_CDATA_SECT_OPEN */
-      else if (parser->m_characterDataHandler)
-        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf, 0);
-#endif
+      else if (0 && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
       else if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, next);
       *startPtr = next;
@@ -3748,35 +3598,31 @@ doCdataSection(XML_Parser parser,
       if (parser->m_characterDataHandler) {
         XML_Char c = 0xA;
         parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
-      }
-      else if (parser->m_defaultHandler)
+      } else if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, next);
       break;
-    case XML_TOK_DATA_CHARS:
-      {
-        XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
-        if (charDataHandler) {
-          if (MUST_CONVERT(enc, s)) {
-            for (;;) {
-              ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
-              const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
-              *eventEndPP = next;
-              charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
-                              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
-              if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
-                break;
-              *eventPP = s;
-            }
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = next;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
           }
-          else
-            charDataHandler(parser->m_handlerArg,
-                            (XML_Char *)s,
-                            (int)((XML_Char *)next - (XML_Char *)s));
-        }
-        else if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-      }
-      break;
+        } else
+          charDataHandler(parser->m_handlerArg, (XML_Char *)s,
+                          (int)((XML_Char *)next - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
     case XML_TOK_INVALID:
       *eventPP = next;
       return XML_ERROR_INVALID_TOKEN;
@@ -3800,7 +3646,7 @@ doCdataSection(XML_Parser parser,
        * statistics.
        *
        * LCOV_EXCL_START
-      */
+       */
       *eventPP = next;
       return XML_ERROR_UNEXPECTED_STATE;
       /* LCOV_EXCL_STOP */
@@ -3813,7 +3659,7 @@ doCdataSection(XML_Parser parser,
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
-    default: ;
+    default:;
     }
   }
   /* not reached */
@@ -3825,13 +3671,11 @@ doCdataSection(XML_Parser parser,
    the whole file is parsed with one call.
 */
 static enum XML_Error PTRCALL
-ignoreSectionProcessor(XML_Parser parser,
-                       const char *start,
-                       const char *end,
-                       const char **endPtr)
-{
-  enum XML_Error result = doIgnoreSection(parser, parser->m_encoding, &start, end,
-                                          endPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                       const char **endPtr) {
+  enum XML_Error result
+      = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
+                        (XML_Bool)! parser->m_parsingStatus.finalBuffer);
   if (result != XML_ERROR_NONE)
     return result;
   if (start) {
@@ -3845,13 +3689,8 @@ ignoreSectionProcessor(XML_Parser parser,
    if the section is not yet closed.
 */
 static enum XML_Error
-doIgnoreSection(XML_Parser parser,
-                const ENCODING *enc,
-                const char **startPtr,
-                const char *end,
-                const char **nextPtr,
-                XML_Bool haveMore)
-{
+doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+                const char *end, const char **nextPtr, XML_Bool haveMore) {
   const char *next;
   int tok;
   const char *s = *startPtr;
@@ -3861,8 +3700,7 @@ doIgnoreSection(XML_Parser parser,
     eventPP = &parser->m_eventPtr;
     *eventPP = s;
     eventEndPP = &parser->m_eventEndPtr;
-  }
-  else {
+  } else {
     /* It's not entirely clear, but it seems the following two lines
      * of code cannot be executed.  The only occasions on which 'enc'
      * is not 'encoding' are when this function is called
@@ -3926,13 +3764,12 @@ doIgnoreSection(XML_Parser parser,
 #endif /* XML_DTD */
 
 static enum XML_Error
-initializeEncoding(XML_Parser parser)
-{
+initializeEncoding(XML_Parser parser) {
   const char *s;
 #ifdef XML_UNICODE
   char encodingBuf[128];
   /* See comments abount `protoclEncodingName` in parserInit() */
-  if (!parser->m_protocolEncodingName)
+  if (! parser->m_protocolEncodingName)
     s = NULL;
   else {
     int i;
@@ -3950,15 +3787,15 @@ initializeEncoding(XML_Parser parser)
 #else
   s = parser->m_protocolEncodingName;
 #endif
-  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(&parser->m_initEncoding, &parser->m_encoding, s))
+  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
+          &parser->m_initEncoding, &parser->m_encoding, s))
     return XML_ERROR_NONE;
   return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
 }
 
 static enum XML_Error
-processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
-               const char *s, const char *next)
-{
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
+               const char *next) {
   const char *encodingName = NULL;
   const XML_Char *storedEncName = NULL;
   const ENCODING *newEncoding = NULL;
@@ -3966,52 +3803,41 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
   const char *versionend;
   const XML_Char *storedversion = NULL;
   int standalone = -1;
-  if (!(parser->m_ns
-        ? XmlParseXmlDeclNS
-        : XmlParseXmlDecl)(isGeneralTextEntity,
-                           parser->m_encoding,
-                           s,
-                           next,
-                           &parser->m_eventPtr,
-                           &version,
-                           &versionend,
-                           &encodingName,
-                           &newEncoding,
-                           &standalone)) {
+  if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
+          isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
+          &version, &versionend, &encodingName, &newEncoding, &standalone)) {
     if (isGeneralTextEntity)
       return XML_ERROR_TEXT_DECL;
     else
       return XML_ERROR_XML_DECL;
   }
-  if (!isGeneralTextEntity && standalone == 1) {
+  if (! isGeneralTextEntity && standalone == 1) {
     parser->m_dtd->standalone = XML_TRUE;
 #ifdef XML_DTD
-    if (parser->m_paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
+    if (parser->m_paramEntityParsing
+        == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
       parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
 #endif /* XML_DTD */
   }
   if (parser->m_xmlDeclHandler) {
     if (encodingName != NULL) {
-      storedEncName = poolStoreString(&parser->m_temp2Pool,
-                                      parser->m_encoding,
-                                      encodingName,
-                                      encodingName
-                                      + XmlNameLength(parser->m_encoding, encodingName));
-      if (!storedEncName)
-              return XML_ERROR_NO_MEMORY;
+      storedEncName = poolStoreString(
+          &parser->m_temp2Pool, parser->m_encoding, encodingName,
+          encodingName + XmlNameLength(parser->m_encoding, encodingName));
+      if (! storedEncName)
+        return XML_ERROR_NO_MEMORY;
       poolFinish(&parser->m_temp2Pool);
     }
     if (version) {
-      storedversion = poolStoreString(&parser->m_temp2Pool,
-                                      parser->m_encoding,
-                                      version,
-                                      versionend - parser->m_encoding->minBytesPerChar);
-      if (!storedversion)
+      storedversion
+          = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
+                            versionend - parser->m_encoding->minBytesPerChar);
+      if (! storedversion)
         return XML_ERROR_NO_MEMORY;
     }
-    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName, standalone);
-  }
-  else if (parser->m_defaultHandler)
+    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
+                             standalone);
+  } else if (parser->m_defaultHandler)
     reportDefault(parser, parser->m_encoding, s, next);
   if (parser->m_protocolEncodingName == NULL) {
     if (newEncoding) {
@@ -4021,20 +3847,19 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
        * this is UTF-16, is it the same endianness?
        */
       if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
-          || (newEncoding->minBytesPerChar == 2 &&
-              newEncoding != parser->m_encoding)) {
+          || (newEncoding->minBytesPerChar == 2
+              && newEncoding != parser->m_encoding)) {
         parser->m_eventPtr = encodingName;
         return XML_ERROR_INCORRECT_ENCODING;
       }
       parser->m_encoding = newEncoding;
-    }
-    else if (encodingName) {
+    } else if (encodingName) {
       enum XML_Error result;
-      if (!storedEncName) {
+      if (! storedEncName) {
         storedEncName = poolStoreString(
-          &parser->m_temp2Pool, parser->m_encoding, encodingName,
-          encodingName + XmlNameLength(parser->m_encoding, encodingName));
-        if (!storedEncName)
+            &parser->m_temp2Pool, parser->m_encoding, encodingName,
+            encodingName + XmlNameLength(parser->m_encoding, encodingName));
+        if (! storedEncName)
           return XML_ERROR_NO_MEMORY;
       }
       result = handleUnknownEncoding(parser, storedEncName);
@@ -4052,8 +3877,7 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
 }
 
 static enum XML_Error
-handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
-{
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
   if (parser->m_unknownEncodingHandler) {
     XML_Encoding info;
     int i;
@@ -4062,21 +3886,17 @@ handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
     info.convert = NULL;
     info.data = NULL;
     info.release = NULL;
-    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData, encodingName,
-                               &info)) {
+    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
+                                         encodingName, &info)) {
       ENCODING *enc;
       parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
-      if (!parser->m_unknownEncodingMem) {
+      if (! parser->m_unknownEncodingMem) {
         if (info.release)
           info.release(info.data);
         return XML_ERROR_NO_MEMORY;
       }
-      enc = (parser->m_ns
-             ? XmlInitUnknownEncodingNS
-             : XmlInitUnknownEncoding)(parser->m_unknownEncodingMem,
-                                       info.map,
-                                       info.convert,
-                                       info.data);
+      enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
+          parser->m_unknownEncodingMem, info.map, info.convert, info.data);
       if (enc) {
         parser->m_unknownEncodingData = info.data;
         parser->m_unknownEncodingRelease = info.release;
@@ -4091,11 +3911,8 @@ handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
 }
 
 static enum XML_Error PTRCALL
-prologInitProcessor(XML_Parser parser,
-                    const char *s,
-                    const char *end,
-                    const char **nextPtr)
-{
+prologInitProcessor(XML_Parser parser, const char *s, const char *end,
+                    const char **nextPtr) {
   enum XML_Error result = initializeEncoding(parser);
   if (result != XML_ERROR_NONE)
     return result;
@@ -4106,11 +3923,8 @@ prologInitProcessor(XML_Parser parser,
 #ifdef XML_DTD
 
 static enum XML_Error PTRCALL
-externalParEntInitProcessor(XML_Parser parser,
-                            const char *s,
-                            const char *end,
-                            const char **nextPtr)
-{
+externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
+                            const char **nextPtr) {
   enum XML_Error result = initializeEncoding(parser);
   if (result != XML_ERROR_NONE)
     return result;
@@ -4122,19 +3936,15 @@ externalParEntInitProcessor(XML_Parser parser,
   if (parser->m_prologState.inEntityValue) {
     parser->m_processor = entityValueInitProcessor;
     return entityValueInitProcessor(parser, s, end, nextPtr);
-  }
-  else {
+  } else {
     parser->m_processor = externalParEntProcessor;
     return externalParEntProcessor(parser, s, end, nextPtr);
   }
 }
 
 static enum XML_Error PTRCALL
-entityValueInitProcessor(XML_Parser parser,
-                         const char *s,
-                         const char *end,
-                         const char **nextPtr)
-{
+entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
+                         const char **nextPtr) {
   int tok;
   const char *start = s;
   const char *next = start;
@@ -4144,7 +3954,7 @@ entityValueInitProcessor(XML_Parser parser,
     tok = XmlPrologTok(parser->m_encoding, start, end, &next);
     parser->m_eventEndPtr = next;
     if (tok <= 0) {
-      if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
@@ -4155,22 +3965,21 @@ entityValueInitProcessor(XML_Parser parser,
         return XML_ERROR_UNCLOSED_TOKEN;
       case XML_TOK_PARTIAL_CHAR:
         return XML_ERROR_PARTIAL_CHAR;
-      case XML_TOK_NONE:   /* start == end */
+      case XML_TOK_NONE: /* start == end */
       default:
         break;
       }
       /* found end of entity value - can store it now */
       return storeEntityValue(parser, parser->m_encoding, s, end);
-    }
-    else if (tok == XML_TOK_XML_DECL) {
+    } else if (tok == XML_TOK_XML_DECL) {
       enum XML_Error result;
       result = processXmlDecl(parser, 0, start, next);
       if (result != XML_ERROR_NONE)
         return result;
-      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For that
-       * to happen, a parameter entity parsing handler must have
-       * attempted to suspend the parser, which fails and raises an
-       * error.  The parser can be aborted, but can't be suspended.
+      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For
+       * that to happen, a parameter entity parsing handler must have attempted
+       * to suspend the parser, which fails and raises an error.  The parser can
+       * be aborted, but can't be suspended.
        */
       if (parser->m_parsingStatus.parsing == XML_FINISHED)
         return XML_ERROR_ABORTED;
@@ -4186,7 +3995,8 @@ entityValueInitProcessor(XML_Parser parser,
        then, when this routine is entered the next time, XmlPrologTok will
        return XML_TOK_INVALID, since the BOM is still in the buffer
     */
-    else if (tok == XML_TOK_BOM && next == end && !parser->m_parsingStatus.finalBuffer) {
+    else if (tok == XML_TOK_BOM && next == end
+             && ! parser->m_parsingStatus.finalBuffer) {
       *nextPtr = next;
       return XML_ERROR_NONE;
     }
@@ -4204,17 +4014,14 @@ entityValueInitProcessor(XML_Parser parser,
 }
 
 static enum XML_Error PTRCALL
-externalParEntProcessor(XML_Parser parser,
-                        const char *s,
-                        const char *end,
-                        const char **nextPtr)
-{
+externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
   const char *next = s;
   int tok;
 
   tok = XmlPrologTok(parser->m_encoding, s, end, &next);
   if (tok <= 0) {
-    if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+    if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
       *nextPtr = s;
       return XML_ERROR_NONE;
     }
@@ -4225,7 +4032,7 @@ externalParEntProcessor(XML_Parser parser,
       return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
       return XML_ERROR_PARTIAL_CHAR;
-    case XML_TOK_NONE:   /* start == end */
+    case XML_TOK_NONE: /* start == end */
     default:
       break;
     }
@@ -4240,16 +4047,13 @@ externalParEntProcessor(XML_Parser parser,
   }
 
   parser->m_processor = prologProcessor;
-  return doProlog(parser, parser->m_encoding, s, end, tok, next,
-                  nextPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE);
 }
 
 static enum XML_Error PTRCALL
-entityValueProcessor(XML_Parser parser,
-                     const char *s,
-                     const char *end,
-                     const char **nextPtr)
-{
+entityValueProcessor(XML_Parser parser, const char *s, const char *end,
+                     const char **nextPtr) {
   const char *start = s;
   const char *next = s;
   const ENCODING *enc = parser->m_encoding;
@@ -4258,7 +4062,7 @@ entityValueProcessor(XML_Parser parser,
   for (;;) {
     tok = XmlPrologTok(enc, start, end, &next);
     if (tok <= 0) {
-      if (!parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
@@ -4269,7 +4073,7 @@ entityValueProcessor(XML_Parser parser,
         return XML_ERROR_UNCLOSED_TOKEN;
       case XML_TOK_PARTIAL_CHAR:
         return XML_ERROR_PARTIAL_CHAR;
-      case XML_TOK_NONE:   /* start == end */
+      case XML_TOK_NONE: /* start == end */
       default:
         break;
       }
@@ -4283,52 +4087,46 @@ entityValueProcessor(XML_Parser parser,
 #endif /* XML_DTD */
 
 static enum XML_Error PTRCALL
-prologProcessor(XML_Parser parser,
-                const char *s,
-                const char *end,
-                const char **nextPtr)
-{
+prologProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
   const char *next = s;
   int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
-  return doProlog(parser, parser->m_encoding, s, end, tok, next,
-                  nextPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE);
 }
 
 static enum XML_Error
-doProlog(XML_Parser parser,
-         const ENCODING *enc,
-         const char *s,
-         const char *end,
-         int tok,
-         const char *next,
-         const char **nextPtr,
-         XML_Bool haveMore)
-{
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
+         int tok, const char *next, const char **nextPtr, XML_Bool haveMore,
+         XML_Bool allowClosingDoctype) {
 #ifdef XML_DTD
-  static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
+  static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'};
 #endif /* XML_DTD */
-  static const XML_Char atypeCDATA[] =
-      { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
-  static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
-  static const XML_Char atypeIDREF[] =
-      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
-  static const XML_Char atypeIDREFS[] =
-      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
-  static const XML_Char atypeENTITY[] =
-      { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
-  static const XML_Char atypeENTITIES[] = { ASCII_E, ASCII_N,
-      ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
-  static const XML_Char atypeNMTOKEN[] = {
-      ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
-  static const XML_Char atypeNMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T,
-      ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
-  static const XML_Char notationPrefix[] = { ASCII_N, ASCII_O, ASCII_T,
-      ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0' };
-  static const XML_Char enumValueSep[] = { ASCII_PIPE, '\0' };
-  static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
+  static const XML_Char atypeCDATA[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+  static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'};
+  static const XML_Char atypeIDREF[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+  static const XML_Char atypeIDREFS[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
+  static const XML_Char atypeENTITY[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+  static const XML_Char atypeENTITIES[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+         ASCII_I, ASCII_E, ASCII_S, '\0'};
+  static const XML_Char atypeNMTOKEN[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+  static const XML_Char atypeNMTOKENS[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+         ASCII_E, ASCII_N, ASCII_S, '\0'};
+  static const XML_Char notationPrefix[]
+      = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,
+         ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'};
+  static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'};
+  static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'};
 
   /* save one level of indirection */
-  DTD * const dtd = parser->m_dtd;
+  DTD *const dtd = parser->m_dtd;
 
   const char **eventPP;
   const char **eventEndPP;
@@ -4337,8 +4135,7 @@ doProlog(XML_Parser parser,
   if (enc == parser->m_encoding) {
     eventPP = &parser->m_eventPtr;
     eventEndPP = &parser->m_eventEndPtr;
-  }
-  else {
+  } else {
     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
   }
@@ -4367,7 +4164,8 @@ doProlog(XML_Parser parser,
       case XML_TOK_NONE:
 #ifdef XML_DTD
         /* for internal PE NOT referenced between declarations */
-        if (enc != parser->m_encoding && !parser->m_openInternalEntities->betweenDecl) {
+        if (enc != parser->m_encoding
+            && ! parser->m_openInternalEntities->betweenDecl) {
           *nextPtr = s;
           return XML_ERROR_NONE;
         }
@@ -4392,19 +4190,18 @@ doProlog(XML_Parser parser,
     }
     role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
     switch (role) {
-    case XML_ROLE_XML_DECL:
-      {
-        enum XML_Error result = processXmlDecl(parser, 0, s, next);
-        if (result != XML_ERROR_NONE)
-          return result;
-        enc = parser->m_encoding;
-        handleDefault = XML_FALSE;
-      }
-      break;
+    case XML_ROLE_XML_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 0, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
     case XML_ROLE_DOCTYPE_NAME:
       if (parser->m_startDoctypeDeclHandler) {
-        parser->m_doctypeName = poolStoreString(&parser->m_tempPool, enc, s, next);
-        if (!parser->m_doctypeName)
+        parser->m_doctypeName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_doctypeName)
           return XML_ERROR_NO_MEMORY;
         poolFinish(&parser->m_tempPool);
         parser->m_doctypePubid = NULL;
@@ -4414,43 +4211,40 @@ doProlog(XML_Parser parser,
       break;
     case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
       if (parser->m_startDoctypeDeclHandler) {
-        parser->m_startDoctypeDeclHandler(parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
-                                parser->m_doctypePubid, 1);
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 1);
         parser->m_doctypeName = NULL;
         poolClear(&parser->m_tempPool);
         handleDefault = XML_FALSE;
       }
       break;
 #ifdef XML_DTD
-    case XML_ROLE_TEXT_DECL:
-      {
-        enum XML_Error result = processXmlDecl(parser, 1, s, next);
-        if (result != XML_ERROR_NONE)
-          return result;
-        enc = parser->m_encoding;
-        handleDefault = XML_FALSE;
-      }
-      break;
+    case XML_ROLE_TEXT_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 1, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
 #endif /* XML_DTD */
     case XML_ROLE_DOCTYPE_PUBLIC_ID:
 #ifdef XML_DTD
       parser->m_useForeignDTD = XML_FALSE;
-      parser->m_declEntity = (ENTITY *)lookup(parser,
-                                    &dtd->paramEntities,
-                                    externalSubsetName,
-                                    sizeof(ENTITY));
-      if (!parser->m_declEntity)
+      parser->m_declEntity = (ENTITY *)lookup(
+          parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+      if (! parser->m_declEntity)
         return XML_ERROR_NO_MEMORY;
 #endif /* XML_DTD */
       dtd->hasParamEntityRefs = XML_TRUE;
       if (parser->m_startDoctypeDeclHandler) {
         XML_Char *pubId;
-        if (!XmlIsPublicId(enc, s, next, eventPP))
+        if (! XmlIsPublicId(enc, s, next, eventPP))
           return XML_ERROR_PUBLICID;
         pubId = poolStoreString(&parser->m_tempPool, enc,
                                 s + enc->minBytesPerChar,
                                 next - enc->minBytesPerChar);
-        if (!pubId)
+        if (! pubId)
           return XML_ERROR_NO_MEMORY;
         normalizePublicId(pubId);
         poolFinish(&parser->m_tempPool);
@@ -4460,15 +4254,14 @@ doProlog(XML_Parser parser,
       }
       /* fall through */
     case XML_ROLE_ENTITY_PUBLIC_ID:
-      if (!XmlIsPublicId(enc, s, next, eventPP))
+      if (! XmlIsPublicId(enc, s, next, eventPP))
         return XML_ERROR_PUBLICID;
     alreadyChecked:
       if (dtd->keepProcessing && parser->m_declEntity) {
-        XML_Char *tem = poolStoreString(&dtd->pool,
-                                        enc,
-                                        s + enc->minBytesPerChar,
-                                        next - enc->minBytesPerChar);
-        if (!tem)
+        XML_Char *tem
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! tem)
           return XML_ERROR_NO_MEMORY;
         normalizePublicId(tem);
         parser->m_declEntity->publicId = tem;
@@ -4481,9 +4274,15 @@ doProlog(XML_Parser parser,
       }
       break;
     case XML_ROLE_DOCTYPE_CLOSE:
+      if (allowClosingDoctype != XML_TRUE) {
+        /* Must not close doctype from within expanded parameter entities */
+        return XML_ERROR_INVALID_TOKEN;
+      }
+
       if (parser->m_doctypeName) {
-        parser->m_startDoctypeDeclHandler(parser->m_handlerArg, parser->m_doctypeName,
-                                parser->m_doctypeSysid, parser->m_doctypePubid, 0);
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 0);
         poolClear(&parser->m_tempPool);
         handleDefault = XML_FALSE;
       }
@@ -4495,12 +4294,11 @@ doProlog(XML_Parser parser,
       if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
         dtd->hasParamEntityRefs = XML_TRUE;
-        if (parser->m_paramEntityParsing && parser->m_externalEntityRefHandler) {
-          ENTITY *entity = (ENTITY *)lookup(parser,
-                                            &dtd->paramEntities,
-                                            externalSubsetName,
-                                            sizeof(ENTITY));
-          if (!entity) {
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
+          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity) {
             /* The external subset name "#" will have already been
              * inserted into the hash table at the start of the
              * external entity parsing, so no allocation will happen
@@ -4511,22 +4309,19 @@ doProlog(XML_Parser parser,
           if (parser->m_useForeignDTD)
             entity->base = parser->m_curBase;
           dtd->paramEntityRead = XML_FALSE;
-          if (!parser->m_externalEntityRefHandler(parser->m_externalEntityRefHandlerArg,
-                                        0,
-                                        entity->base,
-                                        entity->systemId,
-                                        entity->publicId))
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
           if (dtd->paramEntityRead) {
-            if (!dtd->standalone &&
-                parser->m_notStandaloneHandler &&
-                !parser->m_notStandaloneHandler(parser->m_handlerArg))
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
               return XML_ERROR_NOT_STANDALONE;
           }
           /* if we didn't read the foreign DTD then this means that there
              is no external subset and we must reset dtd->hasParamEntityRefs
           */
-          else if (!parser->m_doctypeSysid)
+          else if (! parser->m_doctypeSysid)
             dtd->hasParamEntityRefs = hadParamEntityRefs;
           /* end of DTD - no need to update dtd->keepProcessing */
         }
@@ -4546,24 +4341,21 @@ doProlog(XML_Parser parser,
       if (parser->m_useForeignDTD) {
         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
         dtd->hasParamEntityRefs = XML_TRUE;
-        if (parser->m_paramEntityParsing && parser->m_externalEntityRefHandler) {
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
           ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
-                                            externalSubsetName,
-                                            sizeof(ENTITY));
-          if (!entity)
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity)
             return XML_ERROR_NO_MEMORY;
           entity->base = parser->m_curBase;
           dtd->paramEntityRead = XML_FALSE;
-          if (!parser->m_externalEntityRefHandler(parser->m_externalEntityRefHandlerArg,
-                                        0,
-                                        entity->base,
-                                        entity->systemId,
-                                        entity->publicId))
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
           if (dtd->paramEntityRead) {
-            if (!dtd->standalone &&
-                parser->m_notStandaloneHandler &&
-                !parser->m_notStandaloneHandler(parser->m_handlerArg))
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
               return XML_ERROR_NOT_STANDALONE;
           }
           /* if we didn't read the foreign DTD then this means that there
@@ -4579,12 +4371,12 @@ doProlog(XML_Parser parser,
       return contentProcessor(parser, s, end, nextPtr);
     case XML_ROLE_ATTLIST_ELEMENT_NAME:
       parser->m_declElementType = getElementType(parser, enc, s, next);
-      if (!parser->m_declElementType)
+      if (! parser->m_declElementType)
         return XML_ERROR_NO_MEMORY;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_NAME:
       parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
-      if (!parser->m_declAttributeId)
+      if (! parser->m_declAttributeId)
         return XML_ERROR_NO_MEMORY;
       parser->m_declAttributeIsCdata = XML_FALSE;
       parser->m_declAttributeType = NULL;
@@ -4625,15 +4417,13 @@ doProlog(XML_Parser parser,
         const XML_Char *prefix;
         if (parser->m_declAttributeType) {
           prefix = enumValueSep;
+        } else {
+          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix
+                                                              : enumValueStart);
         }
-        else {
-          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE
-                    ? notationPrefix
-                    : enumValueStart);
-        }
-        if (!poolAppendString(&parser->m_tempPool, prefix))
+        if (! poolAppendString(&parser->m_tempPool, prefix))
           return XML_ERROR_NO_MEMORY;
-        if (!poolAppend(&parser->m_tempPool, enc, s, next))
+        if (! poolAppend(&parser->m_tempPool, enc, s, next))
           return XML_ERROR_NO_MEMORY;
         parser->m_declAttributeType = parser->m_tempPool.start;
         handleDefault = XML_FALSE;
@@ -4642,25 +4432,27 @@ doProlog(XML_Parser parser,
     case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
     case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
       if (dtd->keepProcessing) {
-        if (!defineAttribute(parser->m_declElementType, parser->m_declAttributeId,
-                             parser->m_declAttributeIsCdata, parser->m_declAttributeIsId,
-                             0, parser))
+        if (! defineAttribute(parser->m_declElementType,
+                              parser->m_declAttributeId,
+                              parser->m_declAttributeIsCdata,
+                              parser->m_declAttributeIsId, 0, parser))
           return XML_ERROR_NO_MEMORY;
         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
               || (*parser->m_declAttributeType == XML_T(ASCII_N)
                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
             /* Enumerated or Notation type */
-            if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
-                || !poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
               return XML_ERROR_NO_MEMORY;
             parser->m_declAttributeType = parser->m_tempPool.start;
             poolFinish(&parser->m_tempPool);
           }
           *eventEndPP = s;
-          parser->m_attlistDeclHandler(parser->m_handlerArg, parser->m_declElementType->name,
-                             parser->m_declAttributeId->name, parser->m_declAttributeType,
-                             0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
+              role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
           poolClear(&parser->m_tempPool);
           handleDefault = XML_FALSE;
         }
@@ -4670,35 +4462,34 @@ doProlog(XML_Parser parser,
     case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
       if (dtd->keepProcessing) {
         const XML_Char *attVal;
-        enum XML_Error result =
-          storeAttributeValue(parser, enc, parser->m_declAttributeIsCdata,
-                              s + enc->minBytesPerChar,
-                              next - enc->minBytesPerChar,
-                              &dtd->pool);
+        enum XML_Error result = storeAttributeValue(
+            parser, enc, parser->m_declAttributeIsCdata,
+            s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool);
         if (result)
           return result;
         attVal = poolStart(&dtd->pool);
         poolFinish(&dtd->pool);
         /* ID attributes aren't allowed to have a default */
-        if (!defineAttribute(parser->m_declElementType, parser->m_declAttributeId,
-                             parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
+        if (! defineAttribute(
+                parser->m_declElementType, parser->m_declAttributeId,
+                parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
           return XML_ERROR_NO_MEMORY;
         if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
           if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
               || (*parser->m_declAttributeType == XML_T(ASCII_N)
                   && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
             /* Enumerated or Notation type */
-            if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
-                || !poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
               return XML_ERROR_NO_MEMORY;
             parser->m_declAttributeType = parser->m_tempPool.start;
             poolFinish(&parser->m_tempPool);
           }
           *eventEndPP = s;
-          parser->m_attlistDeclHandler(parser->m_handlerArg, parser->m_declElementType->name,
-                             parser->m_declAttributeId->name, parser->m_declAttributeType,
-                             attVal,
-                             role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType,
+              attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
           poolClear(&parser->m_tempPool);
           handleDefault = XML_FALSE;
         }
@@ -4706,25 +4497,22 @@ doProlog(XML_Parser parser,
       break;
     case XML_ROLE_ENTITY_VALUE:
       if (dtd->keepProcessing) {
-        enum XML_Error result = storeEntityValue(parser, enc,
-                                            s + enc->minBytesPerChar,
-                                            next - enc->minBytesPerChar);
+        enum XML_Error result = storeEntityValue(
+            parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
         if (parser->m_declEntity) {
           parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
-          parser->m_declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));
+          parser->m_declEntity->textLen
+              = (int)(poolLength(&dtd->entityValuePool));
           poolFinish(&dtd->entityValuePool);
           if (parser->m_entityDeclHandler) {
             *eventEndPP = s;
-            parser->m_entityDeclHandler(parser->m_handlerArg,
-                              parser->m_declEntity->name,
-                              parser->m_declEntity->is_param,
-                              parser->m_declEntity->textPtr,
-                              parser->m_declEntity->textLen,
-                              parser->m_curBase, 0, 0, 0);
+            parser->m_entityDeclHandler(
+                parser->m_handlerArg, parser->m_declEntity->name,
+                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
+                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
             handleDefault = XML_FALSE;
           }
-        }
-        else
+        } else
           poolDiscard(&dtd->entityValuePool);
         if (result != XML_ERROR_NONE)
           return result;
@@ -4737,8 +4525,8 @@ doProlog(XML_Parser parser,
       dtd->hasParamEntityRefs = XML_TRUE;
       if (parser->m_startDoctypeDeclHandler) {
         parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
-                                       s + enc->minBytesPerChar,
-                                       next - enc->minBytesPerChar);
+                                                 s + enc->minBytesPerChar,
+                                                 next - enc->minBytesPerChar);
         if (parser->m_doctypeSysid == NULL)
           return XML_ERROR_NO_MEMORY;
         poolFinish(&parser->m_tempPool);
@@ -4750,22 +4538,20 @@ doProlog(XML_Parser parser,
            for the case where no parser->m_startDoctypeDeclHandler is set */
         parser->m_doctypeSysid = externalSubsetName;
 #endif /* XML_DTD */
-      if (!dtd->standalone
+      if (! dtd->standalone
 #ifdef XML_DTD
-          && !parser->m_paramEntityParsing
+          && ! parser->m_paramEntityParsing
 #endif /* XML_DTD */
           && parser->m_notStandaloneHandler
-          && !parser->m_notStandaloneHandler(parser->m_handlerArg))
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
         return XML_ERROR_NOT_STANDALONE;
 #ifndef XML_DTD
       break;
-#else /* XML_DTD */
-      if (!parser->m_declEntity) {
-        parser->m_declEntity = (ENTITY *)lookup(parser,
-                                      &dtd->paramEntities,
-                                      externalSubsetName,
-                                      sizeof(ENTITY));
-        if (!parser->m_declEntity)
+#else  /* XML_DTD */
+      if (! parser->m_declEntity) {
+        parser->m_declEntity = (ENTITY *)lookup(
+            parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+        if (! parser->m_declEntity)
           return XML_ERROR_NO_MEMORY;
         parser->m_declEntity->publicId = NULL;
       }
@@ -4773,10 +4559,10 @@ doProlog(XML_Parser parser,
       /* fall through */
     case XML_ROLE_ENTITY_SYSTEM_ID:
       if (dtd->keepProcessing && parser->m_declEntity) {
-        parser->m_declEntity->systemId = poolStoreString(&dtd->pool, enc,
-                                               s + enc->minBytesPerChar,
-                                               next - enc->minBytesPerChar);
-        if (!parser->m_declEntity->systemId)
+        parser->m_declEntity->systemId
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! parser->m_declEntity->systemId)
           return XML_ERROR_NO_MEMORY;
         parser->m_declEntity->base = parser->m_curBase;
         poolFinish(&dtd->pool);
@@ -4788,115 +4574,103 @@ doProlog(XML_Parser parser,
       }
       break;
     case XML_ROLE_ENTITY_COMPLETE:
-      if (dtd->keepProcessing && parser->m_declEntity && parser->m_entityDeclHandler) {
+      if (dtd->keepProcessing && parser->m_declEntity
+          && parser->m_entityDeclHandler) {
         *eventEndPP = s;
-        parser->m_entityDeclHandler(parser->m_handlerArg,
-                          parser->m_declEntity->name,
-                          parser->m_declEntity->is_param,
-                          0,0,
-                          parser->m_declEntity->base,
-                          parser->m_declEntity->systemId,
-                          parser->m_declEntity->publicId,
-                          0);
+        parser->m_entityDeclHandler(
+            parser->m_handlerArg, parser->m_declEntity->name,
+            parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
+            parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
         handleDefault = XML_FALSE;
       }
       break;
     case XML_ROLE_ENTITY_NOTATION_NAME:
       if (dtd->keepProcessing && parser->m_declEntity) {
-        parser->m_declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);
-        if (!parser->m_declEntity->notation)
+        parser->m_declEntity->notation
+            = poolStoreString(&dtd->pool, enc, s, next);
+        if (! parser->m_declEntity->notation)
           return XML_ERROR_NO_MEMORY;
         poolFinish(&dtd->pool);
         if (parser->m_unparsedEntityDeclHandler) {
           *eventEndPP = s;
-          parser->m_unparsedEntityDeclHandler(parser->m_handlerArg,
-                                    parser->m_declEntity->name,
-                                    parser->m_declEntity->base,
-                                    parser->m_declEntity->systemId,
-                                    parser->m_declEntity->publicId,
-                                    parser->m_declEntity->notation);
+          parser->m_unparsedEntityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
           handleDefault = XML_FALSE;
-        }
-        else if (parser->m_entityDeclHandler) {
+        } else if (parser->m_entityDeclHandler) {
           *eventEndPP = s;
-          parser->m_entityDeclHandler(parser->m_handlerArg,
-                            parser->m_declEntity->name,
-                            0,0,0,
-                            parser->m_declEntity->base,
-                            parser->m_declEntity->systemId,
-                            parser->m_declEntity->publicId,
-                            parser->m_declEntity->notation);
+          parser->m_entityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
           handleDefault = XML_FALSE;
         }
       }
       break;
-    case XML_ROLE_GENERAL_ENTITY_NAME:
-      {
-        if (XmlPredefinedEntityName(enc, s, next)) {
-          parser->m_declEntity = NULL;
-          break;
-        }
-        if (dtd->keepProcessing) {
-          const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
-          if (!name)
-            return XML_ERROR_NO_MEMORY;
-          parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, name,
-                                        sizeof(ENTITY));
-          if (!parser->m_declEntity)
-            return XML_ERROR_NO_MEMORY;
-          if (parser->m_declEntity->name != name) {
-            poolDiscard(&dtd->pool);
-            parser->m_declEntity = NULL;
-          }
-          else {
-            poolFinish(&dtd->pool);
-            parser->m_declEntity->publicId = NULL;
-            parser->m_declEntity->is_param = XML_FALSE;
-            /* if we have a parent parser or are reading an internal parameter
-               entity, then the entity declaration is not considered "internal"
-            */
-            parser->m_declEntity->is_internal = !(parser->m_parentParser || parser->m_openInternalEntities);
-            if (parser->m_entityDeclHandler)
-              handleDefault = XML_FALSE;
-          }
-        }
-        else {
+    case XML_ROLE_GENERAL_ENTITY_NAME: {
+      if (XmlPredefinedEntityName(enc, s, next)) {
+        parser->m_declEntity = NULL;
+        break;
+      }
+      if (dtd->keepProcessing) {
+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_declEntity->name != name) {
           poolDiscard(&dtd->pool);
           parser->m_declEntity = NULL;
+        } else {
+          poolFinish(&dtd->pool);
+          parser->m_declEntity->publicId = NULL;
+          parser->m_declEntity->is_param = XML_FALSE;
+          /* if we have a parent parser or are reading an internal parameter
+             entity, then the entity declaration is not considered "internal"
+          */
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
+          if (parser->m_entityDeclHandler)
+            handleDefault = XML_FALSE;
         }
+      } else {
+        poolDiscard(&dtd->pool);
+        parser->m_declEntity = NULL;
       }
-      break;
+    } break;
     case XML_ROLE_PARAM_ENTITY_NAME:
 #ifdef XML_DTD
       if (dtd->keepProcessing) {
         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
-        if (!name)
+        if (! name)
           return XML_ERROR_NO_MEMORY;
         parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
-                                           name, sizeof(ENTITY));
-        if (!parser->m_declEntity)
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
           return XML_ERROR_NO_MEMORY;
         if (parser->m_declEntity->name != name) {
           poolDiscard(&dtd->pool);
           parser->m_declEntity = NULL;
-        }
-        else {
+        } else {
           poolFinish(&dtd->pool);
           parser->m_declEntity->publicId = NULL;
           parser->m_declEntity->is_param = XML_TRUE;
           /* if we have a parent parser or are reading an internal parameter
              entity, then the entity declaration is not considered "internal"
           */
-          parser->m_declEntity->is_internal = !(parser->m_parentParser || parser->m_openInternalEntities);
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
           if (parser->m_entityDeclHandler)
             handleDefault = XML_FALSE;
         }
-      }
-      else {
+      } else {
         poolDiscard(&dtd->pool);
         parser->m_declEntity = NULL;
       }
-#else /* not XML_DTD */
+#else  /* not XML_DTD */
       parser->m_declEntity = NULL;
 #endif /* XML_DTD */
       break;
@@ -4904,22 +4678,23 @@ doProlog(XML_Parser parser,
       parser->m_declNotationPublicId = NULL;
       parser->m_declNotationName = NULL;
       if (parser->m_notationDeclHandler) {
-        parser->m_declNotationName = poolStoreString(&parser->m_tempPool, enc, s, next);
-        if (!parser->m_declNotationName)
+        parser->m_declNotationName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_declNotationName)
           return XML_ERROR_NO_MEMORY;
         poolFinish(&parser->m_tempPool);
         handleDefault = XML_FALSE;
       }
       break;
     case XML_ROLE_NOTATION_PUBLIC_ID:
-      if (!XmlIsPublicId(enc, s, next, eventPP))
+      if (! XmlIsPublicId(enc, s, next, eventPP))
         return XML_ERROR_PUBLICID;
-      if (parser->m_declNotationName) {  /* means m_notationDeclHandler != NULL */
-        XML_Char *tem = poolStoreString(&parser->m_tempPool,
-                                        enc,
+      if (parser
+              ->m_declNotationName) { /* means m_notationDeclHandler != NULL */
+        XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
                                         s + enc->minBytesPerChar,
                                         next - enc->minBytesPerChar);
-        if (!tem)
+        if (! tem)
           return XML_ERROR_NO_MEMORY;
         normalizePublicId(tem);
         parser->m_declNotationPublicId = tem;
@@ -4929,18 +4704,15 @@ doProlog(XML_Parser parser,
       break;
     case XML_ROLE_NOTATION_SYSTEM_ID:
       if (parser->m_declNotationName && parser->m_notationDeclHandler) {
-        const XML_Char *systemId
-          = poolStoreString(&parser->m_tempPool, enc,
-                            s + enc->minBytesPerChar,
-                            next - enc->minBytesPerChar);
-        if (!systemId)
+        const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
+                                                   s + enc->minBytesPerChar,
+                                                   next - enc->minBytesPerChar);
+        if (! systemId)
           return XML_ERROR_NO_MEMORY;
         *eventEndPP = s;
-        parser->m_notationDeclHandler(parser->m_handlerArg,
-                            parser->m_declNotationName,
-                            parser->m_curBase,
-                            systemId,
-                            parser->m_declNotationPublicId);
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            systemId, parser->m_declNotationPublicId);
         handleDefault = XML_FALSE;
       }
       poolClear(&parser->m_tempPool);
@@ -4948,11 +4720,9 @@ doProlog(XML_Parser parser,
     case XML_ROLE_NOTATION_NO_SYSTEM_ID:
       if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
         *eventEndPP = s;
-        parser->m_notationDeclHandler(parser->m_handlerArg,
-                            parser->m_declNotationName,
-                            parser->m_curBase,
-                            0,
-                            parser->m_declNotationPublicId);
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            0, parser->m_declNotationPublicId);
         handleDefault = XML_FALSE;
       }
       poolClear(&parser->m_tempPool);
@@ -4969,42 +4739,44 @@ doProlog(XML_Parser parser,
         return XML_ERROR_SYNTAX;
       }
 #ifdef XML_DTD
-    case XML_ROLE_IGNORE_SECT:
-      {
-        enum XML_Error result;
-        if (parser->m_defaultHandler)
-          reportDefault(parser, enc, s, next);
-        handleDefault = XML_FALSE;
-        result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
-        if (result != XML_ERROR_NONE)
-          return result;
-        else if (!next) {
-          parser->m_processor = ignoreSectionProcessor;
-          return result;
-        }
+    case XML_ROLE_IGNORE_SECT: {
+      enum XML_Error result;
+      if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      handleDefault = XML_FALSE;
+      result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = ignoreSectionProcessor;
+        return result;
       }
-      break;
+    } break;
 #endif /* XML_DTD */
     case XML_ROLE_GROUP_OPEN:
       if (parser->m_prologState.level >= parser->m_groupSize) {
         if (parser->m_groupSize) {
-          char *temp = (char *)REALLOC(parser, parser->m_groupConnector, parser->m_groupSize *= 2);
-          if (temp == NULL) {
-            parser->m_groupSize /= 2;
-            return XML_ERROR_NO_MEMORY;
+          {
+            char *const new_connector = (char *)REALLOC(
+                parser, parser->m_groupConnector, parser->m_groupSize *= 2);
+            if (new_connector == NULL) {
+              parser->m_groupSize /= 2;
+              return XML_ERROR_NO_MEMORY;
+            }
+            parser->m_groupConnector = new_connector;
           }
-          parser->m_groupConnector = temp;
+
           if (dtd->scaffIndex) {
-            int *temp = (int *)REALLOC(parser, dtd->scaffIndex,
-                          parser->m_groupSize * sizeof(int));
-            if (temp == NULL)
+            int *const new_scaff_index = (int *)REALLOC(
+                parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
+            if (new_scaff_index == NULL)
               return XML_ERROR_NO_MEMORY;
-            dtd->scaffIndex = temp;
+            dtd->scaffIndex = new_scaff_index;
           }
-        }
-        else {
-          parser->m_groupConnector = (char *)MALLOC(parser, parser->m_groupSize = 32);
-          if (!parser->m_groupConnector) {
+        } else {
+          parser->m_groupConnector
+              = (char *)MALLOC(parser, parser->m_groupSize = 32);
+          if (! parser->m_groupConnector) {
             parser->m_groupSize = 0;
             return XML_ERROR_NO_MEMORY;
           }
@@ -5015,6 +4787,7 @@ doProlog(XML_Parser parser,
         int myindex = nextScaffoldPart(parser);
         if (myindex < 0)
           return XML_ERROR_NO_MEMORY;
+        assert(dtd->scaffIndex != NULL);
         dtd->scaffIndex[dtd->scaffLevel] = myindex;
         dtd->scaffLevel++;
         dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
@@ -5033,10 +4806,9 @@ doProlog(XML_Parser parser,
       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
         return XML_ERROR_SYNTAX;
       if (dtd->in_eldecl
-          && !parser->m_groupConnector[parser->m_prologState.level]
+          && ! parser->m_groupConnector[parser->m_prologState.level]
           && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
-              != XML_CTYPE_MIXED)
-          ) {
+              != XML_CTYPE_MIXED)) {
         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
             = XML_CTYPE_CHOICE;
         if (parser->m_elementDeclHandler)
@@ -5048,15 +4820,14 @@ doProlog(XML_Parser parser,
 #ifdef XML_DTD
     case XML_ROLE_INNER_PARAM_ENTITY_REF:
       dtd->hasParamEntityRefs = XML_TRUE;
-      if (!parser->m_paramEntityParsing)
+      if (! parser->m_paramEntityParsing)
         dtd->keepProcessing = dtd->standalone;
       else {
         const XML_Char *name;
         ENTITY *entity;
-        name = poolStoreString(&dtd->pool, enc,
-                                s + enc->minBytesPerChar,
-                                next - enc->minBytesPerChar);
-        if (!name)
+        name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar);
+        if (! name)
           return XML_ERROR_NO_MEMORY;
         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
         poolDiscard(&dtd->pool);
@@ -5064,13 +4835,12 @@ doProlog(XML_Parser parser,
            if yes, check that the entity exists, and that it is internal,
            otherwise call the skipped entity handler
         */
-        if (parser->m_prologState.documentEntity &&
-            (dtd->standalone
-             ? !parser->m_openInternalEntities
-             : !dtd->hasParamEntityRefs)) {
-          if (!entity)
+        if (parser->m_prologState.documentEntity
+            && (dtd->standalone ? ! parser->m_openInternalEntities
+                                : ! dtd->hasParamEntityRefs)) {
+          if (! entity)
             return XML_ERROR_UNDEFINED_ENTITY;
-          else if (!entity->is_internal) {
+          else if (! entity->is_internal) {
             /* It's hard to exhaustively search the code to be sure,
              * but there doesn't seem to be a way of executing the
              * following line.  There are two cases:
@@ -5093,11 +4863,11 @@ doProlog(XML_Parser parser,
              */
             return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
           }
-        }
-        else if (!entity) {
+        } else if (! entity) {
           dtd->keepProcessing = dtd->standalone;
           /* cannot report skipped entities in declarations */
-          if ((role == XML_ROLE_PARAM_ENTITY_REF) && parser->m_skippedEntityHandler) {
+          if ((role == XML_ROLE_PARAM_ENTITY_REF)
+              && parser->m_skippedEntityHandler) {
             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
             handleDefault = XML_FALSE;
           }
@@ -5107,8 +4877,8 @@ doProlog(XML_Parser parser,
           return XML_ERROR_RECURSIVE_ENTITY_REF;
         if (entity->textPtr) {
           enum XML_Error result;
-          XML_Bool betweenDecl =
-            (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
+          XML_Bool betweenDecl
+              = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
           result = processInternalEntity(parser, entity, betweenDecl);
           if (result != XML_ERROR_NONE)
             return result;
@@ -5118,39 +4888,35 @@ doProlog(XML_Parser parser,
         if (parser->m_externalEntityRefHandler) {
           dtd->paramEntityRead = XML_FALSE;
           entity->open = XML_TRUE;
-          if (!parser->m_externalEntityRefHandler(parser->m_externalEntityRefHandlerArg,
-                                        0,
-                                        entity->base,
-                                        entity->systemId,
-                                        entity->publicId)) {
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId)) {
             entity->open = XML_FALSE;
             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
           }
           entity->open = XML_FALSE;
           handleDefault = XML_FALSE;
-          if (!dtd->paramEntityRead) {
+          if (! dtd->paramEntityRead) {
             dtd->keepProcessing = dtd->standalone;
             break;
           }
-        }
-        else {
+        } else {
           dtd->keepProcessing = dtd->standalone;
           break;
         }
       }
 #endif /* XML_DTD */
-      if (!dtd->standalone &&
-          parser->m_notStandaloneHandler &&
-          !parser->m_notStandaloneHandler(parser->m_handlerArg))
+      if (! dtd->standalone && parser->m_notStandaloneHandler
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
         return XML_ERROR_NOT_STANDALONE;
       break;
 
-    /* Element declaration stuff */
+      /* Element declaration stuff */
 
     case XML_ROLE_ELEMENT_NAME:
       if (parser->m_elementDeclHandler) {
         parser->m_declElementType = getElementType(parser, enc, s, next);
-        if (!parser->m_declElementType)
+        if (! parser->m_declElementType)
           return XML_ERROR_NO_MEMORY;
         dtd->scaffLevel = 0;
         dtd->scaffCount = 0;
@@ -5163,18 +4929,19 @@ doProlog(XML_Parser parser,
     case XML_ROLE_CONTENT_EMPTY:
       if (dtd->in_eldecl) {
         if (parser->m_elementDeclHandler) {
-          XML_Content * content = (XML_Content *) MALLOC(parser, sizeof(XML_Content));
-          if (!content)
+          XML_Content *content
+              = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
+          if (! content)
             return XML_ERROR_NO_MEMORY;
           content->quant = XML_CQUANT_NONE;
           content->name = NULL;
           content->numchildren = 0;
           content->children = NULL;
-          content->type = ((role == XML_ROLE_CONTENT_ANY) ?
-                           XML_CTYPE_ANY :
-                           XML_CTYPE_EMPTY);
+          content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY
+                                                          : XML_CTYPE_EMPTY);
           *eventEndPP = s;
-          parser->m_elementDeclHandler(parser->m_handlerArg, parser->m_declElementType->name, content);
+          parser->m_elementDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name, content);
           handleDefault = XML_FALSE;
         }
         dtd->in_eldecl = XML_FALSE;
@@ -5206,22 +4973,22 @@ doProlog(XML_Parser parser,
         ELEMENT_TYPE *el;
         const XML_Char *name;
         int nameLen;
-        const char *nxt = (quant == XML_CQUANT_NONE
-                           ? next
-                           : next - enc->minBytesPerChar);
+        const char *nxt
+            = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
         int myindex = nextScaffoldPart(parser);
         if (myindex < 0)
           return XML_ERROR_NO_MEMORY;
         dtd->scaffold[myindex].type = XML_CTYPE_NAME;
         dtd->scaffold[myindex].quant = quant;
         el = getElementType(parser, enc, s, nxt);
-        if (!el)
+        if (! el)
           return XML_ERROR_NO_MEMORY;
         name = el->name;
         dtd->scaffold[myindex].name = name;
         nameLen = 0;
-        for (; name[nameLen++]; );
-        dtd->contentStringLen +=  nameLen;
+        for (; name[nameLen++];)
+          ;
+        dtd->contentStringLen += nameLen;
         if (parser->m_elementDeclHandler)
           handleDefault = XML_FALSE;
       }
@@ -5245,12 +5012,13 @@ doProlog(XML_Parser parser,
         dtd->scaffLevel--;
         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
         if (dtd->scaffLevel == 0) {
-          if (!handleDefault) {
+          if (! handleDefault) {
             XML_Content *model = build_model(parser);
-            if (!model)
+            if (! model)
               return XML_ERROR_NO_MEMORY;
             *eventEndPP = s;
-            parser->m_elementDeclHandler(parser->m_handlerArg, parser->m_declElementType->name, model);
+            parser->m_elementDeclHandler(
+                parser->m_handlerArg, parser->m_declElementType->name, model);
           }
           dtd->in_eldecl = XML_FALSE;
           dtd->contentStringLen = 0;
@@ -5260,12 +5028,12 @@ doProlog(XML_Parser parser,
       /* End element declaration stuff */
 
     case XML_ROLE_PI:
-      if (!reportProcessingInstruction(parser, enc, s, next))
+      if (! reportProcessingInstruction(parser, enc, s, next))
         return XML_ERROR_NO_MEMORY;
       handleDefault = XML_FALSE;
       break;
     case XML_ROLE_COMMENT:
-      if (!reportComment(parser, enc, s, next))
+      if (! reportComment(parser, enc, s, next))
         return XML_ERROR_NO_MEMORY;
       handleDefault = XML_FALSE;
       break;
@@ -5316,11 +5084,8 @@ doProlog(XML_Parser parser,
 }
 
 static enum XML_Error PTRCALL
-epilogProcessor(XML_Parser parser,
-                const char *s,
-                const char *end,
-                const char **nextPtr)
-{
+epilogProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
   parser->m_processor = epilogProcessor;
   parser->m_eventPtr = s;
   for (;;) {
@@ -5345,24 +5110,24 @@ epilogProcessor(XML_Parser parser,
         reportDefault(parser, parser->m_encoding, s, next);
       break;
     case XML_TOK_PI:
-      if (!reportProcessingInstruction(parser, parser->m_encoding, s, next))
+      if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
         return XML_ERROR_NO_MEMORY;
       break;
     case XML_TOK_COMMENT:
-      if (!reportComment(parser, parser->m_encoding, s, next))
+      if (! reportComment(parser, parser->m_encoding, s, next))
         return XML_ERROR_NO_MEMORY;
       break;
     case XML_TOK_INVALID:
       parser->m_eventPtr = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
-      if (!parser->m_parsingStatus.finalBuffer) {
+      if (! parser->m_parsingStatus.finalBuffer) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
-      if (!parser->m_parsingStatus.finalBuffer) {
+      if (! parser->m_parsingStatus.finalBuffer) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
@@ -5377,15 +5142,13 @@ epilogProcessor(XML_Parser parser,
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
-    default: ;
+    default:;
     }
   }
 }
 
 static enum XML_Error
-processInternalEntity(XML_Parser parser, ENTITY *entity,
-                      XML_Bool betweenDecl)
-{
+processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
   const char *textStart, *textEnd;
   const char *next;
   enum XML_Error result;
@@ -5394,10 +5157,10 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
   if (parser->m_freeInternalEntities) {
     openEntity = parser->m_freeInternalEntities;
     parser->m_freeInternalEntities = openEntity->next;
-  }
-  else {
-    openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
-    if (!openEntity)
+  } else {
+    openEntity
+        = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
+    if (! openEntity)
       return XML_ERROR_NO_MEMORY;
   }
   entity->open = XML_TRUE;
@@ -5416,21 +5179,20 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
 
 #ifdef XML_DTD
   if (entity->is_param) {
-    int tok = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
-    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd, tok,
-                      next, &next, XML_FALSE);
-  }
-  else
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_FALSE);
+  } else
 #endif /* XML_DTD */
-    result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding, textStart,
-                       textEnd, &next, XML_FALSE);
+    result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
+                       textStart, textEnd, &next, XML_FALSE);
 
   if (result == XML_ERROR_NONE) {
     if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
       entity->processed = (int)(next - textStart);
       parser->m_processor = internalEntityProcessor;
-    }
-    else {
+    } else {
       entity->open = XML_FALSE;
       parser->m_openInternalEntities = openEntity->next;
       /* put openEntity back in list of free instances */
@@ -5442,17 +5204,14 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
 }
 
 static enum XML_Error PTRCALL
-internalEntityProcessor(XML_Parser parser,
-                        const char *s,
-                        const char *end,
-                        const char **nextPtr)
-{
+internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
   ENTITY *entity;
   const char *textStart, *textEnd;
   const char *next;
   enum XML_Error result;
   OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
-  if (!openEntity)
+  if (! openEntity)
     return XML_ERROR_UNEXPECTED_STATE;
 
   entity = openEntity->entity;
@@ -5463,22 +5222,23 @@ internalEntityProcessor(XML_Parser parser,
 
 #ifdef XML_DTD
   if (entity->is_param) {
-    int tok = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
-    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd, tok,
-                      next, &next, XML_FALSE);
-  }
-  else
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_TRUE);
+  } else
 #endif /* XML_DTD */
-    result = doContent(parser, openEntity->startTagLevel, parser->m_internalEncoding,
-                       textStart, textEnd, &next, XML_FALSE);
+    result = doContent(parser, openEntity->startTagLevel,
+                       parser->m_internalEncoding, textStart, textEnd, &next,
+                       XML_FALSE);
 
   if (result != XML_ERROR_NONE)
     return result;
-  else if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+  else if (textEnd != next
+           && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
     entity->processed = (int)(next - (char *)entity->textPtr);
     return result;
-  }
-  else {
+  } else {
     entity->open = XML_FALSE;
     parser->m_openInternalEntities = openEntity->next;
     /* put openEntity back in list of free instances */
@@ -5492,49 +5252,45 @@ internalEntityProcessor(XML_Parser parser,
     parser->m_processor = prologProcessor;
     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
     return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
-                    (XML_Bool)!parser->m_parsingStatus.finalBuffer);
-  }
-  else
+                    (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE);
+  } else
 #endif /* XML_DTD */
   {
     parser->m_processor = contentProcessor;
     /* see externalEntityContentProcessor vs contentProcessor */
-    return doContent(parser, parser->m_parentParser ? 1 : 0, parser->m_encoding, s, end,
-                     nextPtr, (XML_Bool)!parser->m_parsingStatus.finalBuffer);
+    return doContent(parser, parser->m_parentParser ? 1 : 0, parser->m_encoding,
+                     s, end, nextPtr,
+                     (XML_Bool)! parser->m_parsingStatus.finalBuffer);
   }
 }
 
 static enum XML_Error PTRCALL
-errorProcessor(XML_Parser parser,
-               const char *UNUSED_P(s),
-               const char *UNUSED_P(end),
-               const char **UNUSED_P(nextPtr))
-{
+errorProcessor(XML_Parser parser, const char *s, const char *end,
+               const char **nextPtr) {
+  UNUSED_P(s);
+  UNUSED_P(end);
+  UNUSED_P(nextPtr);
   return parser->m_errorCode;
 }
 
 static enum XML_Error
 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
-                    const char *ptr, const char *end,
-                    STRING_POOL *pool)
-{
-  enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,
-                                               end, pool);
+                    const char *ptr, const char *end, STRING_POOL *pool) {
+  enum XML_Error result
+      = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
   if (result)
     return result;
-  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
+  if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
     poolChop(pool);
-  if (!poolAppendChar(pool, XML_T('\0')))
+  if (! poolAppendChar(pool, XML_T('\0')))
     return XML_ERROR_NO_MEMORY;
   return XML_ERROR_NONE;
 }
 
 static enum XML_Error
 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
-                     const char *ptr, const char *end,
-                     STRING_POOL *pool)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+                     const char *ptr, const char *end, STRING_POOL *pool) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   for (;;) {
     const char *next;
     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
@@ -5549,38 +5305,35 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
       if (enc == parser->m_encoding)
         parser->m_eventPtr = ptr;
       return XML_ERROR_INVALID_TOKEN;
-    case XML_TOK_CHAR_REF:
-      {
-        XML_Char buf[XML_ENCODE_MAX];
-        int i;
-        int n = XmlCharRefNumber(enc, ptr);
-        if (n < 0) {
-          if (enc == parser->m_encoding)
-            parser->m_eventPtr = ptr;
-          return XML_ERROR_BAD_CHAR_REF;
-        }
-        if (!isCdata
-            && n == 0x20 /* space */
-            && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
-          break;
-        n = XmlEncode(n, (ICHAR *)buf);
-        /* The XmlEncode() functions can never return 0 here.  That
-         * error return happens if the code point passed in is either
-         * negative or greater than or equal to 0x110000.  The
-         * XmlCharRefNumber() functions will all return a number
-         * strictly less than 0x110000 or a negative value if an error
-         * occurred.  The negative value is intercepted above, so
-         * XmlEncode() is never passed a value it might return an
-         * error for.
-         */
-        for (i = 0; i < n; i++) {
-          if (!poolAppendChar(pool, buf[i]))
-            return XML_ERROR_NO_MEMORY;
-        }
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, ptr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BAD_CHAR_REF;
       }
-      break;
+      if (! isCdata && n == 0x20 /* space */
+          && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+        break;
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (! poolAppendChar(pool, buf[i]))
+          return XML_ERROR_NO_MEMORY;
+      }
+    } break;
     case XML_TOK_DATA_CHARS:
-      if (!poolAppend(pool, enc, ptr, next))
+      if (! poolAppend(pool, enc, ptr, next))
         return XML_ERROR_NO_MEMORY;
       break;
     case XML_TOK_TRAILING_CR:
@@ -5588,109 +5341,103 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
       /* fall through */
     case XML_TOK_ATTRIBUTE_VALUE_S:
     case XML_TOK_DATA_NEWLINE:
-      if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+      if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
         break;
-      if (!poolAppendChar(pool, 0x20))
+      if (! poolAppendChar(pool, 0x20))
         return XML_ERROR_NO_MEMORY;
       break;
-    case XML_TOK_ENTITY_REF:
-      {
-        const XML_Char *name;
-        ENTITY *entity;
-        char checkEntityDecl;
-        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
-                                              ptr + enc->minBytesPerChar,
-                                              next - enc->minBytesPerChar);
-        if (ch) {
-          if (!poolAppendChar(pool, ch))
-                return XML_ERROR_NO_MEMORY;
-          break;
-        }
-        name = poolStoreString(&parser->m_temp2Pool, enc,
-                               ptr + enc->minBytesPerChar,
-                               next - enc->minBytesPerChar);
-        if (!name)
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      char checkEntityDecl;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+        if (! poolAppendChar(pool, ch))
           return XML_ERROR_NO_MEMORY;
-        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
-        poolDiscard(&parser->m_temp2Pool);
-        /* First, determine if a check for an existing declaration is needed;
-           if yes, check that the entity exists, and that it is internal.
-        */
-        if (pool == &dtd->pool)  /* are we called from prolog? */
-          checkEntityDecl =
+        break;
+      }
+      name = poolStoreString(&parser->m_temp2Pool, enc,
+                             ptr + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&parser->m_temp2Pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal.
+      */
+      if (pool == &dtd->pool) /* are we called from prolog? */
+        checkEntityDecl =
 #ifdef XML_DTD
-              parser->m_prologState.documentEntity &&
+            parser->m_prologState.documentEntity &&
 #endif /* XML_DTD */
-              (dtd->standalone
-               ? !parser->m_openInternalEntities
-               : !dtd->hasParamEntityRefs);
-        else /* if (pool == &parser->m_tempPool): we are called from content */
-          checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;
-        if (checkEntityDecl) {
-          if (!entity)
-            return XML_ERROR_UNDEFINED_ENTITY;
-          else if (!entity->is_internal)
-            return XML_ERROR_ENTITY_DECLARED_IN_PE;
-        }
-        else if (!entity) {
-          /* Cannot report skipped entity here - see comments on
-             parser->m_skippedEntityHandler.
-          if (parser->m_skippedEntityHandler)
-            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
-          */
-          /* Cannot call the default handler because this would be
-             out of sync with the call to the startElementHandler.
-          if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
-            reportDefault(parser, enc, ptr, next);
-          */
-          break;
-        }
-        if (entity->open) {
-          if (enc == parser->m_encoding) {
-            /* It does not appear that this line can be executed.
-             *
-             * The "if (entity->open)" check catches recursive entity
-             * definitions.  In order to be called with an open
-             * entity, it must have gone through this code before and
-             * been through the recursive call to
-             * appendAttributeValue() some lines below.  That call
-             * sets the local encoding ("enc") to the parser's
-             * internal encoding (internal_utf8 or internal_utf16),
-             * which can never be the same as the principle encoding.
-             * It doesn't appear there is another code path that gets
-             * here with entity->open being TRUE.
-             *
-             * Since it is not certain that this logic is watertight,
-             * we keep the line and merely exclude it from coverage
-             * tests.
-             */
-            parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
-          }
-          return XML_ERROR_RECURSIVE_ENTITY_REF;
-        }
-        if (entity->notation) {
-          if (enc == parser->m_encoding)
-            parser->m_eventPtr = ptr;
-          return XML_ERROR_BINARY_ENTITY_REF;
-        }
-        if (!entity->textPtr) {
-          if (enc == parser->m_encoding)
-            parser->m_eventPtr = ptr;
-          return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
-        }
-        else {
-          enum XML_Error result;
-          const XML_Char *textEnd = entity->textPtr + entity->textLen;
-          entity->open = XML_TRUE;
-          result = appendAttributeValue(parser, parser->m_internalEncoding, isCdata,
-                                        (char *)entity->textPtr,
-                                        (char *)textEnd, pool);
-          entity->open = XML_FALSE;
-          if (result)
-            return result;
+            (dtd->standalone ? ! parser->m_openInternalEntities
+                             : ! dtd->hasParamEntityRefs);
+      else /* if (pool == &parser->m_tempPool): we are called from content */
+        checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;
+      if (checkEntityDecl) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        /* Cannot report skipped entity here - see comments on
+           parser->m_skippedEntityHandler.
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        */
+        /* Cannot call the default handler because this would be
+           out of sync with the call to the startElementHandler.
+        if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
+          reportDefault(parser, enc, ptr, next);
+        */
+        break;
+      }
+      if (entity->open) {
+        if (enc == parser->m_encoding) {
+          /* It does not appear that this line can be executed.
+           *
+           * The "if (entity->open)" check catches recursive entity
+           * definitions.  In order to be called with an open
+           * entity, it must have gone through this code before and
+           * been through the recursive call to
+           * appendAttributeValue() some lines below.  That call
+           * sets the local encoding ("enc") to the parser's
+           * internal encoding (internal_utf8 or internal_utf16),
+           * which can never be the same as the principle encoding.
+           * It doesn't appear there is another code path that gets
+           * here with entity->open being TRUE.
+           *
+           * Since it is not certain that this logic is watertight,
+           * we keep the line and merely exclude it from coverage
+           * tests.
+           */
+          parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
         }
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
       }
-      break;
+      if (entity->notation) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BINARY_ENTITY_REF;
+      }
+      if (! entity->textPtr) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+      } else {
+        enum XML_Error result;
+        const XML_Char *textEnd = entity->textPtr + entity->textLen;
+        entity->open = XML_TRUE;
+        result = appendAttributeValue(parser, parser->m_internalEncoding,
+                                      isCdata, (char *)entity->textPtr,
+                                      (char *)textEnd, pool);
+        entity->open = XML_FALSE;
+        if (result)
+          return result;
+      }
+    } break;
     default:
       /* The only token returned by XmlAttributeValueTok() that does
        * not have an explicit case here is XML_TOK_PARTIAL_CHAR.
@@ -5714,12 +5461,9 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
 }
 
 static enum XML_Error
-storeEntityValue(XML_Parser parser,
-                 const ENCODING *enc,
-                 const char *entityTextPtr,
-                 const char *entityTextEnd)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                 const char *entityTextPtr, const char *entityTextEnd) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   STRING_POOL *pool = &(dtd->entityValuePool);
   enum XML_Error result = XML_ERROR_NONE;
 #ifdef XML_DTD
@@ -5729,8 +5473,8 @@ storeEntityValue(XML_Parser parser,
   /* never return Null for the value argument in EntityDeclHandler,
      since this would indicate an external entity; therefore we
      have to make sure that entityValuePool.start is not null */
-  if (!pool->blocks) {
-    if (!poolGrow(pool))
+  if (! pool->blocks) {
+    if (! poolGrow(pool))
       return XML_ERROR_NO_MEMORY;
   }
 
@@ -5746,13 +5490,13 @@ storeEntityValue(XML_Parser parser,
         name = poolStoreString(&parser->m_tempPool, enc,
                                entityTextPtr + enc->minBytesPerChar,
                                next - enc->minBytesPerChar);
-        if (!name) {
+        if (! name) {
           result = XML_ERROR_NO_MEMORY;
           goto endEntityValue;
         }
         entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
         poolDiscard(&parser->m_tempPool);
-        if (!entity) {
+        if (! entity) {
           /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
           /* cannot report skipped entity here - see comments on
              parser->m_skippedEntityHandler
@@ -5772,29 +5516,23 @@ storeEntityValue(XML_Parser parser,
           if (parser->m_externalEntityRefHandler) {
             dtd->paramEntityRead = XML_FALSE;
             entity->open = XML_TRUE;
-            if (!parser->m_externalEntityRefHandler(parser->m_externalEntityRefHandlerArg,
-                                          0,
-                                          entity->base,
-                                          entity->systemId,
-                                          entity->publicId)) {
+            if (! parser->m_externalEntityRefHandler(
+                    parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                    entity->systemId, entity->publicId)) {
               entity->open = XML_FALSE;
               result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
               goto endEntityValue;
             }
             entity->open = XML_FALSE;
-            if (!dtd->paramEntityRead)
+            if (! dtd->paramEntityRead)
               dtd->keepProcessing = dtd->standalone;
-          }
-          else
+          } else
             dtd->keepProcessing = dtd->standalone;
-        }
-        else {
+        } else {
           entity->open = XML_TRUE;
-          result = storeEntityValue(parser,
-                                    parser->m_internalEncoding,
-                                    (char *)entity->textPtr,
-                                    (char *)(entity->textPtr
-                                             + entity->textLen));
+          result = storeEntityValue(
+              parser, parser->m_internalEncoding, (char *)entity->textPtr,
+              (char *)(entity->textPtr + entity->textLen));
           entity->open = XML_FALSE;
           if (result)
             goto endEntityValue;
@@ -5812,7 +5550,7 @@ storeEntityValue(XML_Parser parser,
       goto endEntityValue;
     case XML_TOK_ENTITY_REF:
     case XML_TOK_DATA_CHARS:
-      if (!poolAppend(pool, enc, entityTextPtr, next)) {
+      if (! poolAppend(pool, enc, entityTextPtr, next)) {
         result = XML_ERROR_NO_MEMORY;
         goto endEntityValue;
       }
@@ -5821,42 +5559,40 @@ storeEntityValue(XML_Parser parser,
       next = entityTextPtr + enc->minBytesPerChar;
       /* fall through */
     case XML_TOK_DATA_NEWLINE:
-      if (pool->end == pool->ptr && !poolGrow(pool)) {
-              result = XML_ERROR_NO_MEMORY;
+      if (pool->end == pool->ptr && ! poolGrow(pool)) {
+        result = XML_ERROR_NO_MEMORY;
         goto endEntityValue;
       }
       *(pool->ptr)++ = 0xA;
       break;
-    case XML_TOK_CHAR_REF:
-      {
-        XML_Char buf[XML_ENCODE_MAX];
-        int i;
-        int n = XmlCharRefNumber(enc, entityTextPtr);
-        if (n < 0) {
-          if (enc == parser->m_encoding)
-            parser->m_eventPtr = entityTextPtr;
-          result = XML_ERROR_BAD_CHAR_REF;
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, entityTextPtr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = entityTextPtr;
+        result = XML_ERROR_BAD_CHAR_REF;
+        goto endEntityValue;
+      }
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (pool->end == pool->ptr && ! poolGrow(pool)) {
+          result = XML_ERROR_NO_MEMORY;
           goto endEntityValue;
         }
-        n = XmlEncode(n, (ICHAR *)buf);
-        /* The XmlEncode() functions can never return 0 here.  That
-         * error return happens if the code point passed in is either
-         * negative or greater than or equal to 0x110000.  The
-         * XmlCharRefNumber() functions will all return a number
-         * strictly less than 0x110000 or a negative value if an error
-         * occurred.  The negative value is intercepted above, so
-         * XmlEncode() is never passed a value it might return an
-         * error for.
-         */
-        for (i = 0; i < n; i++) {
-          if (pool->end == pool->ptr && !poolGrow(pool)) {
-            result = XML_ERROR_NO_MEMORY;
-            goto endEntityValue;
-          }
-          *(pool->ptr)++ = buf[i];
-        }
+        *(pool->ptr)++ = buf[i];
       }
-      break;
+    } break;
     case XML_TOK_PARTIAL:
       if (enc == parser->m_encoding)
         parser->m_eventPtr = entityTextPtr;
@@ -5891,8 +5627,7 @@ endEntityValue:
 }
 
 static void FASTCALL
-normalizeLines(XML_Char *s)
-{
+normalizeLines(XML_Char *s) {
   XML_Char *p;
   for (;; s++) {
     if (*s == XML_T('\0'))
@@ -5906,8 +5641,7 @@ normalizeLines(XML_Char *s)
       *p++ = 0xA;
       if (*++s == 0xA)
         s++;
-    }
-    else
+    } else
       *p++ = *s++;
   } while (*s);
   *p = XML_T('\0');
@@ -5915,12 +5649,11 @@ normalizeLines(XML_Char *s)
 
 static int
 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
-                            const char *start, const char *end)
-{
+                            const char *start, const char *end) {
   const XML_Char *target;
   XML_Char *data;
   const char *tem;
-  if (!parser->m_processingInstructionHandler) {
+  if (! parser->m_processingInstructionHandler) {
     if (parser->m_defaultHandler)
       reportDefault(parser, enc, start, end);
     return 1;
@@ -5928,13 +5661,12 @@ reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
   start += enc->minBytesPerChar * 2;
   tem = start + XmlNameLength(enc, start);
   target = poolStoreString(&parser->m_tempPool, enc, start, tem);
-  if (!target)
+  if (! target)
     return 0;
   poolFinish(&parser->m_tempPool);
-  data = poolStoreString(&parser->m_tempPool, enc,
-                        XmlSkipS(enc, tem),
-                        end - enc->minBytesPerChar*2);
-  if (!data)
+  data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
+                         end - enc->minBytesPerChar * 2);
+  if (! data)
     return 0;
   normalizeLines(data);
   parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
@@ -5943,20 +5675,18 @@ reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
 }
 
 static int
-reportComment(XML_Parser parser, const ENCODING *enc,
-              const char *start, const char *end)
-{
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
+              const char *end) {
   XML_Char *data;
-  if (!parser->m_commentHandler) {
+  if (! parser->m_commentHandler) {
     if (parser->m_defaultHandler)
       reportDefault(parser, enc, start, end);
     return 1;
   }
-  data = poolStoreString(&parser->m_tempPool,
-                         enc,
+  data = poolStoreString(&parser->m_tempPool, enc,
                          start + enc->minBytesPerChar * 4,
                          end - enc->minBytesPerChar * 3);
-  if (!data)
+  if (! data)
     return 0;
   normalizeLines(data);
   parser->m_commentHandler(parser->m_handlerArg, data);
@@ -5965,9 +5695,8 @@ reportComment(XML_Parser parser, const ENCODING *enc,
 }
 
 static void
-reportDefault(XML_Parser parser, const ENCODING *enc,
-              const char *s, const char *end)
-{
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
+              const char *end) {
   if (MUST_CONVERT(enc, s)) {
     enum XML_Convert_Result convert_res;
     const char **eventPP;
@@ -5975,8 +5704,7 @@ reportDefault(XML_Parser parser, const ENCODING *enc,
     if (enc == parser->m_encoding) {
       eventPP = &parser->m_eventPtr;
       eventEndPP = &parser->m_eventEndPtr;
-    }
-    else {
+    } else {
       /* To get here, two things must be true; the parser must be
        * using a character encoding that is not the same as the
        * encoding passed in, and the encoding passed in must need
@@ -5999,21 +5727,22 @@ reportDefault(XML_Parser parser, const ENCODING *enc,
     }
     do {
       ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
-      convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+      convert_res
+          = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
       *eventEndPP = s;
-      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf, (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
+                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
       *eventPP = s;
-    } while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
-  }
-  else
-    parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
+    } while ((convert_res != XML_CONVERT_COMPLETED)
+             && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
+  } else
+    parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
+                             (int)((XML_Char *)end - (XML_Char *)s));
 }
 
-
 static int
 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
-                XML_Bool isId, const XML_Char *value, XML_Parser parser)
-{
+                XML_Bool isId, const XML_Char *value, XML_Parser parser) {
   DEFAULT_ATTRIBUTE *att;
   if (value || isId) {
     /* The handling of default attributes gets messed up if we have
@@ -6022,24 +5751,23 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
     for (i = 0; i < type->nDefaultAtts; i++)
       if (attId == type->defaultAtts[i].id)
         return 1;
-    if (isId && !type->idAtt && !attId->xmlns)
+    if (isId && ! type->idAtt && ! attId->xmlns)
       type->idAtt = attId;
   }
   if (type->nDefaultAtts == type->allocDefaultAtts) {
     if (type->allocDefaultAtts == 0) {
       type->allocDefaultAtts = 8;
-      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(parser, type->allocDefaultAtts
-                            * sizeof(DEFAULT_ATTRIBUTE));
-      if (!type->defaultAtts) {
+      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(
+          parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! type->defaultAtts) {
         type->allocDefaultAtts = 0;
         return 0;
       }
-    }
-    else {
+    } else {
       DEFAULT_ATTRIBUTE *temp;
       int count = type->allocDefaultAtts * 2;
-      temp = (DEFAULT_ATTRIBUTE *)
-        REALLOC(parser, type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
+      temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
+                                          (count * sizeof(DEFAULT_ATTRIBUTE)));
       if (temp == NULL)
         return 0;
       type->allocDefaultAtts = count;
@@ -6050,92 +5778,89 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
   att->id = attId;
   att->value = value;
   att->isCdata = isCdata;
-  if (!isCdata)
+  if (! isCdata)
     attId->maybeTokenized = XML_TRUE;
   type->nDefaultAtts += 1;
   return 1;
 }
 
 static int
-setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   const XML_Char *name;
   for (name = elementType->name; *name; name++) {
     if (*name == XML_T(ASCII_COLON)) {
       PREFIX *prefix;
       const XML_Char *s;
       for (s = elementType->name; s != name; s++) {
-        if (!poolAppendChar(&dtd->pool, *s))
+        if (! poolAppendChar(&dtd->pool, *s))
           return 0;
       }
-      if (!poolAppendChar(&dtd->pool, XML_T('\0')))
+      if (! poolAppendChar(&dtd->pool, XML_T('\0')))
         return 0;
       prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
                                 sizeof(PREFIX));
-      if (!prefix)
+      if (! prefix)
         return 0;
       if (prefix->name == poolStart(&dtd->pool))
         poolFinish(&dtd->pool);
       else
         poolDiscard(&dtd->pool);
       elementType->prefix = prefix;
-
+      break;
     }
   }
   return 1;
 }
 
 static ATTRIBUTE_ID *
-getAttributeId(XML_Parser parser, const ENCODING *enc,
-               const char *start, const char *end)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   ATTRIBUTE_ID *id;
   const XML_Char *name;
-  if (!poolAppendChar(&dtd->pool, XML_T('\0')))
+  if (! poolAppendChar(&dtd->pool, XML_T('\0')))
     return NULL;
   name = poolStoreString(&dtd->pool, enc, start, end);
-  if (!name)
+  if (! name)
     return NULL;
   /* skip quotation mark - its storage will be re-used (like in name[-1]) */
   ++name;
-  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
-  if (!id)
+  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
+                              sizeof(ATTRIBUTE_ID));
+  if (! id)
     return NULL;
   if (id->name != name)
     poolDiscard(&dtd->pool);
   else {
     poolFinish(&dtd->pool);
-    if (!parser->m_ns)
+    if (! parser->m_ns)
       ;
-    else if (name[0] == XML_T(ASCII_x)
-        && name[1] == XML_T(ASCII_m)
-        && name[2] == XML_T(ASCII_l)
-        && name[3] == XML_T(ASCII_n)
-        && name[4] == XML_T(ASCII_s)
-        && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
+    else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)
+             && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)
+             && name[4] == XML_T(ASCII_s)
+             && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
       if (name[5] == XML_T('\0'))
         id->prefix = &dtd->defaultPrefix;
       else
-        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
+        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
+                                      sizeof(PREFIX));
       id->xmlns = XML_TRUE;
-    }
-    else {
+    } else {
       int i;
       for (i = 0; name[i]; i++) {
         /* attributes without prefix are *not* in the default namespace */
         if (name[i] == XML_T(ASCII_COLON)) {
           int j;
           for (j = 0; j < i; j++) {
-            if (!poolAppendChar(&dtd->pool, name[j]))
+            if (! poolAppendChar(&dtd->pool, name[j]))
               return NULL;
           }
-          if (!poolAppendChar(&dtd->pool, XML_T('\0')))
+          if (! poolAppendChar(&dtd->pool, XML_T('\0')))
             return NULL;
-          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
-                                        sizeof(PREFIX));
-          if (!id->prefix)
+          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
+                                        poolStart(&dtd->pool), sizeof(PREFIX));
+          if (! id->prefix)
             return NULL;
           if (id->prefix->name == poolStart(&dtd->pool))
             poolFinish(&dtd->pool);
@@ -6152,22 +5877,22 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,
 #define CONTEXT_SEP XML_T(ASCII_FF)
 
 static const XML_Char *
-getContext(XML_Parser parser)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+getContext(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   HASH_TABLE_ITER iter;
   XML_Bool needSep = XML_FALSE;
 
   if (dtd->defaultPrefix.binding) {
     int i;
     int len;
-    if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
       return NULL;
     len = dtd->defaultPrefix.binding->uriLen;
     if (parser->m_namespaceSeparator)
       len--;
     for (i = 0; i < len; i++) {
-      if (!poolAppendChar(&parser->m_tempPool, dtd->defaultPrefix.binding->uri[i])) {
+      if (! poolAppendChar(&parser->m_tempPool,
+                           dtd->defaultPrefix.binding->uri[i])) {
         /* Because of memory caching, I don't believe this line can be
          * executed.
          *
@@ -6199,9 +5924,9 @@ getContext(XML_Parser parser)
     int len;
     const XML_Char *s;
     PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
-    if (!prefix)
+    if (! prefix)
       break;
-    if (!prefix->binding) {
+    if (! prefix->binding) {
       /* This test appears to be (justifiable) paranoia.  There does
        * not seem to be a way of injecting a prefix without a binding
        * that doesn't get errored long before this function is called.
@@ -6210,98 +5935,96 @@ getContext(XML_Parser parser)
        */
       continue; /* LCOV_EXCL_LINE */
     }
-    if (needSep && !poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
       return NULL;
     for (s = prefix->name; *s; s++)
-      if (!poolAppendChar(&parser->m_tempPool, *s))
+      if (! poolAppendChar(&parser->m_tempPool, *s))
         return NULL;
-    if (!poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
       return NULL;
     len = prefix->binding->uriLen;
     if (parser->m_namespaceSeparator)
       len--;
     for (i = 0; i < len; i++)
-      if (!poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
+      if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
         return NULL;
     needSep = XML_TRUE;
   }
 
-
   hashTableIterInit(&iter, &(dtd->generalEntities));
   for (;;) {
     const XML_Char *s;
     ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
-    if (!e)
+    if (! e)
       break;
-    if (!e->open)
+    if (! e->open)
       continue;
-    if (needSep && !poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
       return NULL;
     for (s = e->name; *s; s++)
-      if (!poolAppendChar(&parser->m_tempPool, *s))
+      if (! poolAppendChar(&parser->m_tempPool, *s))
         return 0;
     needSep = XML_TRUE;
   }
 
-  if (!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+  if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
     return NULL;
   return parser->m_tempPool.start;
 }
 
 static XML_Bool
-setContext(XML_Parser parser, const XML_Char *context)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+setContext(XML_Parser parser, const XML_Char *context) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   const XML_Char *s = context;
 
   while (*context != XML_T('\0')) {
     if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
       ENTITY *e;
-      if (!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
         return XML_FALSE;
-      e = (ENTITY *)lookup(parser, &dtd->generalEntities, poolStart(&parser->m_tempPool), 0);
+      e = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                           poolStart(&parser->m_tempPool), 0);
       if (e)
         e->open = XML_TRUE;
       if (*s != XML_T('\0'))
         s++;
       context = s;
       poolDiscard(&parser->m_tempPool);
-    }
-    else if (*s == XML_T(ASCII_EQUALS)) {
+    } else if (*s == XML_T(ASCII_EQUALS)) {
       PREFIX *prefix;
       if (poolLength(&parser->m_tempPool) == 0)
         prefix = &dtd->defaultPrefix;
       else {
-        if (!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+        if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
           return XML_FALSE;
-        prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&parser->m_tempPool),
-                                  sizeof(PREFIX));
-        if (!prefix)
+        prefix
+            = (PREFIX *)lookup(parser, &dtd->prefixes,
+                               poolStart(&parser->m_tempPool), sizeof(PREFIX));
+        if (! prefix)
           return XML_FALSE;
         if (prefix->name == poolStart(&parser->m_tempPool)) {
           prefix->name = poolCopyString(&dtd->pool, prefix->name);
-          if (!prefix->name)
+          if (! prefix->name)
             return XML_FALSE;
         }
         poolDiscard(&parser->m_tempPool);
       }
-      for (context = s + 1;
-           *context != CONTEXT_SEP && *context != XML_T('\0');
+      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0');
            context++)
-        if (!poolAppendChar(&parser->m_tempPool, *context))
+        if (! poolAppendChar(&parser->m_tempPool, *context))
           return XML_FALSE;
-      if (!poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
         return XML_FALSE;
       if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
-                     &parser->m_inheritedBindings) != XML_ERROR_NONE)
+                     &parser->m_inheritedBindings)
+          != XML_ERROR_NONE)
         return XML_FALSE;
       poolDiscard(&parser->m_tempPool);
       if (*context != XML_T('\0'))
         ++context;
       s = context;
-    }
-    else {
-      if (!poolAppendChar(&parser->m_tempPool, *s))
+    } else {
+      if (! poolAppendChar(&parser->m_tempPool, *s))
         return XML_FALSE;
       s++;
     }
@@ -6310,8 +6033,7 @@ setContext(XML_Parser parser, const XML_Char *context)
 }
 
 static void FASTCALL
-normalizePublicId(XML_Char *publicId)
-{
+normalizePublicId(XML_Char *publicId) {
   XML_Char *p = publicId;
   XML_Char *s;
   for (s = publicId; *s; s++) {
@@ -6332,8 +6054,7 @@ normalizePublicId(XML_Char *publicId)
 }
 
 static DTD *
-dtdCreate(const XML_Memory_Handling_Suite *ms)
-{
+dtdCreate(const XML_Memory_Handling_Suite *ms) {
   DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
   if (p == NULL)
     return p;
@@ -6365,13 +6086,12 @@ dtdCreate(const XML_Memory_Handling_Suite *ms)
 }
 
 static void
-dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)
-{
+dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms) {
   HASH_TABLE_ITER iter;
   hashTableIterInit(&iter, &(p->elementTypes));
   for (;;) {
     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
-    if (!e)
+    if (! e)
       break;
     if (e->allocDefaultAtts != 0)
       ms->free_fcn(e->defaultAtts);
@@ -6407,13 +6127,12 @@ dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)
 }
 
 static void
-dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)
-{
+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms) {
   HASH_TABLE_ITER iter;
   hashTableIterInit(&iter, &(p->elementTypes));
   for (;;) {
     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
-    if (!e)
+    if (! e)
       break;
     if (e->allocDefaultAtts != 0)
       ms->free_fcn(e->defaultAtts);
@@ -6438,8 +6157,8 @@ dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)
    The new DTD has already been initialized.
 */
 static int
-dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
-{
+dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+        const XML_Memory_Handling_Suite *ms) {
   HASH_TABLE_ITER iter;
 
   /* Copy the prefix table. */
@@ -6448,12 +6167,12 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_H
   for (;;) {
     const XML_Char *name;
     const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
-    if (!oldP)
+    if (! oldP)
       break;
     name = poolCopyString(&(newDtd->pool), oldP->name);
-    if (!name)
+    if (! name)
       return 0;
-    if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
+    if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
       return 0;
   }
 
@@ -6466,18 +6185,18 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_H
     const XML_Char *name;
     const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
 
-    if (!oldA)
+    if (! oldA)
       break;
     /* Remember to allocate the scratch byte before the name. */
-    if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
+    if (! poolAppendChar(&(newDtd->pool), XML_T('\0')))
       return 0;
     name = poolCopyString(&(newDtd->pool), oldA->name);
-    if (!name)
+    if (! name)
       return 0;
     ++name;
     newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
                                   sizeof(ATTRIBUTE_ID));
-    if (!newA)
+    if (! newA)
       return 0;
     newA->maybeTokenized = oldA->maybeTokenized;
     if (oldA->prefix) {
@@ -6499,57 +6218,52 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_H
     ELEMENT_TYPE *newE;
     const XML_Char *name;
     const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
-    if (!oldE)
+    if (! oldE)
       break;
     name = poolCopyString(&(newDtd->pool), oldE->name);
-    if (!name)
+    if (! name)
       return 0;
     newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
                                   sizeof(ELEMENT_TYPE));
-    if (!newE)
+    if (! newE)
       return 0;
     if (oldE->nDefaultAtts) {
-      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
-          ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
-      if (!newE->defaultAtts) {
+      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)ms->malloc_fcn(
+          oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! newE->defaultAtts) {
         return 0;
       }
     }
     if (oldE->idAtt)
-      newE->idAtt = (ATTRIBUTE_ID *)
-          lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0);
+      newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),
+                                           oldE->idAtt->name, 0);
     newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
     if (oldE->prefix)
       newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
                                       oldE->prefix->name, 0);
     for (i = 0; i < newE->nDefaultAtts; i++) {
-      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
-          lookup(oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(
+          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
       if (oldE->defaultAtts[i].value) {
         newE->defaultAtts[i].value
             = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
-        if (!newE->defaultAtts[i].value)
+        if (! newE->defaultAtts[i].value)
           return 0;
-      }
-      else
+      } else
         newE->defaultAtts[i].value = NULL;
     }
   }
 
   /* Copy the entity tables. */
-  if (!copyEntityTable(oldParser,
-                       &(newDtd->generalEntities),
-                       &(newDtd->pool),
-                       &(oldDtd->generalEntities)))
-      return 0;
+  if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),
+                        &(oldDtd->generalEntities)))
+    return 0;
 
 #ifdef XML_DTD
-  if (!copyEntityTable(oldParser,
-                       &(newDtd->paramEntities),
-                       &(newDtd->pool),
-                       &(oldDtd->paramEntities)))
-      return 0;
+  if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),
+                        &(oldDtd->paramEntities)))
+    return 0;
   newDtd->paramEntityRead = oldDtd->paramEntityRead;
 #endif /* XML_DTD */
 
@@ -6566,14 +6280,11 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd, const XML_Memory_H
   newDtd->scaffIndex = oldDtd->scaffIndex;
 
   return 1;
-}  /* End dtdCopy */
+} /* End dtdCopy */
 
 static int
-copyEntityTable(XML_Parser oldParser,
-                HASH_TABLE *newTable,
-                STRING_POOL *newPool,
-                const HASH_TABLE *oldTable)
-{
+copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
+                STRING_POOL *newPool, const HASH_TABLE *oldTable) {
   HASH_TABLE_ITER iter;
   const XML_Char *cachedOldBase = NULL;
   const XML_Char *cachedNewBase = NULL;
@@ -6584,17 +6295,17 @@ copyEntityTable(XML_Parser oldParser,
     ENTITY *newE;
     const XML_Char *name;
     const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
-    if (!oldE)
+    if (! oldE)
       break;
     name = poolCopyString(newPool, oldE->name);
-    if (!name)
+    if (! name)
       return 0;
     newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
-    if (!newE)
+    if (! newE)
       return 0;
     if (oldE->systemId) {
       const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
-      if (!tem)
+      if (! tem)
         return 0;
       newE->systemId = tem;
       if (oldE->base) {
@@ -6603,29 +6314,28 @@ copyEntityTable(XML_Parser oldParser,
         else {
           cachedOldBase = oldE->base;
           tem = poolCopyString(newPool, cachedOldBase);
-          if (!tem)
+          if (! tem)
             return 0;
           cachedNewBase = newE->base = tem;
         }
       }
       if (oldE->publicId) {
         tem = poolCopyString(newPool, oldE->publicId);
-        if (!tem)
+        if (! tem)
           return 0;
         newE->publicId = tem;
       }
-    }
-    else {
-      const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,
-                                            oldE->textLen);
-      if (!tem)
+    } else {
+      const XML_Char *tem
+          = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
+      if (! tem)
         return 0;
       newE->textPtr = tem;
       newE->textLen = oldE->textLen;
     }
     if (oldE->notation) {
       const XML_Char *tem = poolCopyString(newPool, oldE->notation);
-      if (!tem)
+      if (! tem)
         return 0;
       newE->notation = tem;
     }
@@ -6638,8 +6348,7 @@ copyEntityTable(XML_Parser oldParser,
 #define INIT_POWER 6
 
 static XML_Bool FASTCALL
-keyeq(KEY s1, KEY s2)
-{
+keyeq(KEY s1, KEY s2) {
   for (; *s1 == *s2; s1++, s2++)
     if (*s1 == 0)
       return XML_TRUE;
@@ -6647,23 +6356,21 @@ keyeq(KEY s1, KEY s2)
 }
 
 static size_t
-keylen(KEY s)
-{
+keylen(KEY s) {
   size_t len = 0;
-  for (; *s; s++, len++);
+  for (; *s; s++, len++)
+    ;
   return len;
 }
 
 static void
-copy_salt_to_sipkey(XML_Parser parser, struct sipkey * key)
-{
+copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
   key->k[0] = 0;
   key->k[1] = get_hash_secret_salt(parser);
 }
 
 static unsigned long FASTCALL
-hash(XML_Parser parser, KEY s)
-{
+hash(XML_Parser parser, KEY s) {
   struct siphash state;
   struct sipkey key;
   (void)sip24_valid;
@@ -6674,26 +6381,24 @@ hash(XML_Parser parser, KEY s)
 }
 
 static NAMED *
-lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
-{
+lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
   size_t i;
   if (table->size == 0) {
     size_t tsize;
-    if (!createSize)
+    if (! createSize)
       return NULL;
     table->power = INIT_POWER;
     /* table->size is a power of 2 */
     table->size = (size_t)1 << INIT_POWER;
     tsize = table->size * sizeof(NAMED *);
     table->v = (NAMED **)table->mem->malloc_fcn(tsize);
-    if (!table->v) {
+    if (! table->v) {
       table->size = 0;
       return NULL;
     }
     memset(table->v, 0, tsize);
     i = hash(parser, name) & ((unsigned long)table->size - 1);
-  }
-  else {
+  } else {
     unsigned long h = hash(parser, name);
     unsigned long mask = (unsigned long)table->size - 1;
     unsigned char step = 0;
@@ -6701,11 +6406,11 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
     while (table->v[i]) {
       if (keyeq(name, table->v[i]->name))
         return table->v[i];
-      if (!step)
+      if (! step)
         step = PROBE_STEP(h, mask, table->power);
       i < step ? (i += table->size - step) : (i -= step);
     }
-    if (!createSize)
+    if (! createSize)
       return NULL;
 
     /* check for overflow (table is half full) */
@@ -6715,7 +6420,7 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
       unsigned long newMask = (unsigned long)newSize - 1;
       size_t tsize = newSize * sizeof(NAMED *);
       NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
-      if (!newV)
+      if (! newV)
         return NULL;
       memset(newV, 0, tsize);
       for (i = 0; i < table->size; i++)
@@ -6724,7 +6429,7 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
           size_t j = newHash & newMask;
           step = 0;
           while (newV[j]) {
-            if (!step)
+            if (! step)
               step = PROBE_STEP(newHash, newMask, newPower);
             j < step ? (j += newSize - step) : (j -= step);
           }
@@ -6737,14 +6442,14 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
       i = h & newMask;
       step = 0;
       while (table->v[i]) {
-        if (!step)
+        if (! step)
           step = PROBE_STEP(h, newMask, newPower);
         i < step ? (i += newSize - step) : (i -= step);
       }
     }
   }
   table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
-  if (!table->v[i])
+  if (! table->v[i])
     return NULL;
   memset(table->v[i], 0, createSize);
   table->v[i]->name = name;
@@ -6753,8 +6458,7 @@ lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
 }
 
 static void FASTCALL
-hashTableClear(HASH_TABLE *table)
-{
+hashTableClear(HASH_TABLE *table) {
   size_t i;
   for (i = 0; i < table->size; i++) {
     table->mem->free_fcn(table->v[i]);
@@ -6764,8 +6468,7 @@ hashTableClear(HASH_TABLE *table)
 }
 
 static void FASTCALL
-hashTableDestroy(HASH_TABLE *table)
-{
+hashTableDestroy(HASH_TABLE *table) {
   size_t i;
   for (i = 0; i < table->size; i++)
     table->mem->free_fcn(table->v[i]);
@@ -6773,8 +6476,7 @@ hashTableDestroy(HASH_TABLE *table)
 }
 
 static void FASTCALL
-hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)
-{
+hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms) {
   p->power = 0;
   p->size = 0;
   p->used = 0;
@@ -6783,15 +6485,13 @@ hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)
 }
 
 static void FASTCALL
-hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
-{
+hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {
   iter->p = table->v;
   iter->end = iter->p + table->size;
 }
 
-static NAMED * FASTCALL
-hashTableIterNext(HASH_TABLE_ITER *iter)
-{
+static NAMED *FASTCALL
+hashTableIterNext(HASH_TABLE_ITER *iter) {
   while (iter->p != iter->end) {
     NAMED *tem = *(iter->p)++;
     if (tem)
@@ -6801,8 +6501,7 @@ hashTableIterNext(HASH_TABLE_ITER *iter)
 }
 
 static void FASTCALL
-poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)
-{
+poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms) {
   pool->blocks = NULL;
   pool->freeBlocks = NULL;
   pool->start = NULL;
@@ -6812,9 +6511,8 @@ poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)
 }
 
 static void FASTCALL
-poolClear(STRING_POOL *pool)
-{
-  if (!pool->freeBlocks)
+poolClear(STRING_POOL *pool) {
+  if (! pool->freeBlocks)
     pool->freeBlocks = pool->blocks;
   else {
     BLOCK *p = pool->blocks;
@@ -6832,8 +6530,7 @@ poolClear(STRING_POOL *pool)
 }
 
 static void FASTCALL
-poolDestroy(STRING_POOL *pool)
-{
+poolDestroy(STRING_POOL *pool) {
   BLOCK *p = pool->blocks;
   while (p) {
     BLOCK *tem = p->next;
@@ -6849,26 +6546,26 @@ poolDestroy(STRING_POOL *pool)
 }
 
 static XML_Char *
-poolAppend(STRING_POOL *pool, const ENCODING *enc,
-           const char *ptr, const char *end)
-{
-  if (!pool->ptr && !poolGrow(pool))
+poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+           const char *end) {
+  if (! pool->ptr && ! poolGrow(pool))
     return NULL;
   for (;;) {
-    const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
-    if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+    const enum XML_Convert_Result convert_res = XmlConvert(
+        enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
+    if ((convert_res == XML_CONVERT_COMPLETED)
+        || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
       break;
-    if (!poolGrow(pool))
+    if (! poolGrow(pool))
       return NULL;
   }
   return pool->start;
 }
 
-static const XML_Char * FASTCALL
-poolCopyString(STRING_POOL *pool, const XML_Char *s)
-{
+static const XML_Char *FASTCALL
+poolCopyString(STRING_POOL *pool, const XML_Char *s) {
   do {
-    if (!poolAppendChar(pool, *s))
+    if (! poolAppendChar(pool, *s))
       return NULL;
   } while (*s++);
   s = pool->start;
@@ -6877,9 +6574,8 @@ poolCopyString(STRING_POOL *pool, const XML_Char *s)
 }
 
 static const XML_Char *
-poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
-{
-  if (!pool->ptr && !poolGrow(pool)) {
+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {
+  if (! pool->ptr && ! poolGrow(pool)) {
     /* The following line is unreachable given the current usage of
      * poolCopyStringN().  Currently it is called from exactly one
      * place to copy the text of a simple general entity.  By that
@@ -6894,7 +6590,7 @@ poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
     return NULL; /* LCOV_EXCL_LINE */
   }
   for (; n > 0; --n, s++) {
-    if (!poolAppendChar(pool, *s))
+    if (! poolAppendChar(pool, *s))
       return NULL;
   }
   s = pool->start;
@@ -6902,11 +6598,10 @@ poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
   return s;
 }
 
-static const XML_Char * FASTCALL
-poolAppendString(STRING_POOL *pool, const XML_Char *s)
-{
+static const XML_Char *FASTCALL
+poolAppendString(STRING_POOL *pool, const XML_Char *s) {
   while (*s) {
-    if (!poolAppendChar(pool, *s))
+    if (! poolAppendChar(pool, *s))
       return NULL;
     s++;
   }
@@ -6914,20 +6609,18 @@ poolAppendString(STRING_POOL *pool, const XML_Char *s)
 }
 
 static XML_Char *
-poolStoreString(STRING_POOL *pool, const ENCODING *enc,
-                const char *ptr, const char *end)
-{
-  if (!poolAppend(pool, enc, ptr, end))
+poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+                const char *end) {
+  if (! poolAppend(pool, enc, ptr, end))
     return NULL;
-  if (pool->ptr == pool->end && !poolGrow(pool))
+  if (pool->ptr == pool->end && ! poolGrow(pool))
     return NULL;
   *(pool->ptr)++ = 0;
   return pool->start;
 }
 
 static size_t
-poolBytesToAllocateFor(int blockSize)
-{
+poolBytesToAllocateFor(int blockSize) {
   /* Unprotected math would be:
   ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
   **
@@ -6935,7 +6628,7 @@ poolBytesToAllocateFor(int blockSize)
   ** For a + b * c we check b * c in isolation first, so that addition of a
   ** on top has no chance of making us accept a small non-negative number
   */
-  const size_t stretch = sizeof(XML_Char);  /* can be 4 bytes */
+  const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
 
   if (blockSize <= 0)
     return 0;
@@ -6945,8 +6638,8 @@ poolBytesToAllocateFor(int blockSize)
 
   {
     const int stretchedBlockSize = blockSize * (int)stretch;
-    const int bytesToAllocate = (int)(
-        offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
+    const int bytesToAllocate
+        = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
     if (bytesToAllocate < 0)
       return 0;
 
@@ -6955,8 +6648,7 @@ poolBytesToAllocateFor(int blockSize)
 }
 
 static XML_Bool FASTCALL
-poolGrow(STRING_POOL *pool)
-{
+poolGrow(STRING_POOL *pool) {
   if (pool->freeBlocks) {
     if (pool->start == 0) {
       pool->blocks = pool->freeBlocks;
@@ -6982,7 +6674,7 @@ poolGrow(STRING_POOL *pool)
   }
   if (pool->blocks && pool->start == pool->blocks->s) {
     BLOCK *temp;
-    int blockSize = (int)((unsigned)(pool->end - pool->start)*2U);
+    int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);
     size_t bytesToAllocate;
 
     /* NOTE: Needs to be calculated prior to calling `realloc`
@@ -7003,8 +6695,8 @@ poolGrow(STRING_POOL *pool)
     if (bytesToAllocate == 0)
       return XML_FALSE;
 
-    temp = (BLOCK *)
-      pool->mem->realloc_fcn(pool->blocks, (unsigned)bytesToAllocate);
+    temp = (BLOCK *)pool->mem->realloc_fcn(pool->blocks,
+                                           (unsigned)bytesToAllocate);
     if (temp == NULL)
       return XML_FALSE;
     pool->blocks = temp;
@@ -7012,8 +6704,7 @@ poolGrow(STRING_POOL *pool)
     pool->ptr = pool->blocks->s + offsetInsideBlock;
     pool->start = pool->blocks->s;
     pool->end = pool->start + blockSize;
-  }
-  else {
+  } else {
     BLOCK *tem;
     int blockSize = (int)(pool->end - pool->start);
     size_t bytesToAllocate;
@@ -7028,7 +6719,7 @@ poolGrow(STRING_POOL *pool)
        * function).  Either way it isn't readily testable, so we
        * exclude it from the coverage statistics.
        */
-      return XML_FALSE;  /* LCOV_EXCL_LINE */
+      return XML_FALSE; /* LCOV_EXCL_LINE */
     }
 
     if (blockSize < INIT_BLOCK_SIZE)
@@ -7046,14 +6737,13 @@ poolGrow(STRING_POOL *pool)
       return XML_FALSE;
 
     tem = (BLOCK *)pool->mem->malloc_fcn(bytesToAllocate);
-    if (!tem)
+    if (! tem)
       return XML_FALSE;
     tem->size = blockSize;
     tem->next = pool->blocks;
     pool->blocks = tem;
     if (pool->ptr != pool->start)
-      memcpy(tem->s, pool->start,
-             (pool->ptr - pool->start) * sizeof(XML_Char));
+      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
     pool->ptr = tem->s + (pool->ptr - pool->start);
     pool->start = tem->s;
     pool->end = tem->s + blockSize;
@@ -7062,15 +6752,14 @@ poolGrow(STRING_POOL *pool)
 }
 
 static int FASTCALL
-nextScaffoldPart(XML_Parser parser)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
-  CONTENT_SCAFFOLD * me;
+nextScaffoldPart(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  CONTENT_SCAFFOLD *me;
   int next;
 
-  if (!dtd->scaffIndex) {
+  if (! dtd->scaffIndex) {
     dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
-    if (!dtd->scaffIndex)
+    if (! dtd->scaffIndex)
       return -1;
     dtd->scaffIndex[0] = 0;
   }
@@ -7078,15 +6767,14 @@ nextScaffoldPart(XML_Parser parser)
   if (dtd->scaffCount >= dtd->scaffSize) {
     CONTENT_SCAFFOLD *temp;
     if (dtd->scaffold) {
-      temp = (CONTENT_SCAFFOLD *)
-        REALLOC(parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
+      temp = (CONTENT_SCAFFOLD *)REALLOC(
+          parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
       if (temp == NULL)
         return -1;
       dtd->scaffSize *= 2;
-    }
-    else {
+    } else {
       temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
-                                        * sizeof(CONTENT_SCAFFOLD));
+                                                    * sizeof(CONTENT_SCAFFOLD));
       if (temp == NULL)
         return -1;
       dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
@@ -7096,11 +6784,12 @@ nextScaffoldPart(XML_Parser parser)
   next = dtd->scaffCount++;
   me = &dtd->scaffold[next];
   if (dtd->scaffLevel) {
-    CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];
+    CONTENT_SCAFFOLD *parent
+        = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];
     if (parent->lastchild) {
       dtd->scaffold[parent->lastchild].nextsib = next;
     }
-    if (!parent->childcnt)
+    if (! parent->childcnt)
       parent->firstchild = next;
     parent->lastchild = next;
     parent->childcnt++;
@@ -7110,13 +6799,9 @@ nextScaffoldPart(XML_Parser parser)
 }
 
 static void
-build_node(XML_Parser parser,
-           int src_node,
-           XML_Content *dest,
-           XML_Content **contpos,
-           XML_Char **strpos)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+build_node(XML_Parser parser, int src_node, XML_Content *dest,
+           XML_Content **contpos, XML_Char **strpos) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   dest->type = dtd->scaffold[src_node].type;
   dest->quant = dtd->scaffold[src_node].quant;
   if (dest->type == XML_CTYPE_NAME) {
@@ -7125,21 +6810,19 @@ build_node(XML_Parser parser,
     src = dtd->scaffold[src_node].name;
     for (;;) {
       *(*strpos)++ = *src;
-      if (!*src)
+      if (! *src)
         break;
       src++;
     }
     dest->numchildren = 0;
     dest->children = NULL;
-  }
-  else {
+  } else {
     unsigned int i;
     int cn;
     dest->numchildren = dtd->scaffold[src_node].childcnt;
     dest->children = *contpos;
     *contpos += dest->numchildren;
-    for (i = 0, cn = dtd->scaffold[src_node].firstchild;
-         i < dest->numchildren;
+    for (i = 0, cn = dtd->scaffold[src_node].firstchild; i < dest->numchildren;
          i++, cn = dtd->scaffold[cn].nextsib) {
       build_node(parser, cn, &(dest->children[i]), contpos, strpos);
     }
@@ -7148,20 +6831,19 @@ build_node(XML_Parser parser,
 }
 
 static XML_Content *
-build_model (XML_Parser parser)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+build_model(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   XML_Content *ret;
   XML_Content *cpos;
-  XML_Char * str;
+  XML_Char *str;
   int allocsize = (dtd->scaffCount * sizeof(XML_Content)
                    + (dtd->contentStringLen * sizeof(XML_Char)));
 
   ret = (XML_Content *)MALLOC(parser, allocsize);
-  if (!ret)
+  if (! ret)
     return NULL;
 
-  str =  (XML_Char *) (&ret[dtd->scaffCount]);
+  str = (XML_Char *)(&ret[dtd->scaffCount]);
   cpos = &ret[1];
 
   build_node(parser, 0, ret, &cpos, &str);
@@ -7169,49 +6851,45 @@ build_model (XML_Parser parser)
 }
 
 static ELEMENT_TYPE *
-getElementType(XML_Parser parser,
-               const ENCODING *enc,
-               const char *ptr,
-               const char *end)
-{
-  DTD * const dtd = parser->m_dtd;  /* save one level of indirection */
+getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
   const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
   ELEMENT_TYPE *ret;
 
-  if (!name)
+  if (! name)
     return NULL;
-  ret = (ELEMENT_TYPE *) lookup(parser, &dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
-  if (!ret)
+  ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
+                               sizeof(ELEMENT_TYPE));
+  if (! ret)
     return NULL;
   if (ret->name != name)
     poolDiscard(&dtd->pool);
   else {
     poolFinish(&dtd->pool);
-    if (!setElementTypePrefix(parser, ret))
+    if (! setElementTypePrefix(parser, ret))
       return NULL;
   }
   return ret;
 }
 
 static XML_Char *
-copyString(const XML_Char *s,
-           const XML_Memory_Handling_Suite *memsuite)
-{
-    int charsRequired = 0;
-    XML_Char *result;
-
-    /* First determine how long the string is */
-    while (s[charsRequired] != 0) {
-      charsRequired++;
-    }
-    /* Include the terminator */
+copyString(const XML_Char *s, const XML_Memory_Handling_Suite *memsuite) {
+  int charsRequired = 0;
+  XML_Char *result;
+
+  /* First determine how long the string is */
+  while (s[charsRequired] != 0) {
     charsRequired++;
+  }
+  /* Include the terminator */
+  charsRequired++;
 
-    /* Now allocate space for the copy */
-    result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
-    if (result == NULL)
-        return NULL;
-    /* Copy the original into place */
-    memcpy(result, s, charsRequired * sizeof(XML_Char));
-    return result;
+  /* Now allocate space for the copy */
+  result = memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
+  if (result == NULL)
+    return NULL;
+  /* Copy the original into place */
+  memcpy(result, s, charsRequired * sizeof(XML_Char));
+  return result;
 }
diff --git a/contrib/expat/lib/xmlrole.c b/contrib/expat/lib/xmlrole.c
index 708507d575be..4d3e3e86e9e8 100644
--- a/contrib/expat/lib/xmlrole.c
+++ b/contrib/expat/lib/xmlrole.c
@@ -33,11 +33,11 @@
 #include <stddef.h>
 
 #ifdef _WIN32
-#include "winconfig.h"
+#  include "winconfig.h"
 #else
-#ifdef HAVE_EXPAT_CONFIG_H
-#include <expat_config.h>
-#endif
+#  ifdef HAVE_EXPAT_CONFIG_H
+#    include <expat_config.h>
+#  endif
 #endif /* ndef _WIN32 */
 
 #include "expat_external.h"
@@ -52,107 +52,88 @@
 
 */
 
-static const char KW_ANY[] = {
-    ASCII_A, ASCII_N, ASCII_Y, '\0' };
-static const char KW_ATTLIST[] = {
-    ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
-static const char KW_CDATA[] = {
-    ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
-static const char KW_DOCTYPE[] = {
-    ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
-static const char KW_ELEMENT[] = {
-    ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
-static const char KW_EMPTY[] = {
-    ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
-static const char KW_ENTITIES[] = {
-    ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S,
-    '\0' };
-static const char KW_ENTITY[] = {
-    ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
-static const char KW_FIXED[] = {
-    ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
-static const char KW_ID[] = {
-    ASCII_I, ASCII_D, '\0' };
-static const char KW_IDREF[] = {
-    ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
-static const char KW_IDREFS[] = {
-    ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
+static const char KW_ANY[] = {ASCII_A, ASCII_N, ASCII_Y, '\0'};
+static const char KW_ATTLIST[]
+    = {ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0'};
+static const char KW_CDATA[]
+    = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_DOCTYPE[]
+    = {ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0'};
+static const char KW_ELEMENT[]
+    = {ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0'};
+static const char KW_EMPTY[]
+    = {ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0'};
+static const char KW_ENTITIES[] = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+                                   ASCII_I, ASCII_E, ASCII_S, '\0'};
+static const char KW_ENTITY[]
+    = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+static const char KW_FIXED[]
+    = {ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0'};
+static const char KW_ID[] = {ASCII_I, ASCII_D, '\0'};
+static const char KW_IDREF[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+static const char KW_IDREFS[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
 #ifdef XML_DTD
-static const char KW_IGNORE[] = {
-    ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
+static const char KW_IGNORE[]
+    = {ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0'};
 #endif
-static const char KW_IMPLIED[] = {
-    ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
+static const char KW_IMPLIED[]
+    = {ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0'};
 #ifdef XML_DTD
-static const char KW_INCLUDE[] = {
-    ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
+static const char KW_INCLUDE[]
+    = {ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0'};
 #endif
-static const char KW_NDATA[] = {
-    ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
-static const char KW_NMTOKEN[] = {
-    ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
-static const char KW_NMTOKENS[] = {
-    ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S,
-    '\0' };
-static const char KW_NOTATION[] =
-    { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N,
-      '\0' };
-static const char KW_PCDATA[] = {
-    ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
-static const char KW_PUBLIC[] = {
-    ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
-static const char KW_REQUIRED[] = {
-    ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D,
-    '\0' };
-static const char KW_SYSTEM[] = {
-    ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
+static const char KW_NDATA[]
+    = {ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_NMTOKEN[]
+    = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+static const char KW_NMTOKENS[] = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+                                   ASCII_E, ASCII_N, ASCII_S, '\0'};
+static const char KW_NOTATION[] = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T,
+                                   ASCII_I, ASCII_O, ASCII_N, '\0'};
+static const char KW_PCDATA[]
+    = {ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_PUBLIC[]
+    = {ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0'};
+static const char KW_REQUIRED[] = {ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I,
+                                   ASCII_R, ASCII_E, ASCII_D, '\0'};
+static const char KW_SYSTEM[]
+    = {ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0'};
 
 #ifndef MIN_BYTES_PER_CHAR
-#define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
+#  define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
 #endif
 
 #ifdef XML_DTD
-#define setTopLevel(state) \
-  ((state)->handler = ((state)->documentEntity \
-                       ? internalSubset \
-                       : externalSubset1))
+#  define setTopLevel(state)                                                   \
+    ((state)->handler                                                          \
+     = ((state)->documentEntity ? internalSubset : externalSubset1))
 #else /* not XML_DTD */
-#define setTopLevel(state) ((state)->handler = internalSubset)
+#  define setTopLevel(state) ((state)->handler = internalSubset)
 #endif /* not XML_DTD */
 
-typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state,
-                                   int tok,
-                                   const char *ptr,
-                                   const char *end,
+typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state, int tok,
+                                   const char *ptr, const char *end,
                                    const ENCODING *enc);
 
-static PROLOG_HANDLER
-  prolog0, prolog1, prolog2,
-  doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
-  internalSubset,
-  entity0, entity1, entity2, entity3, entity4, entity5, entity6,
-  entity7, entity8, entity9, entity10,
-  notation0, notation1, notation2, notation3, notation4,
-  attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
-  attlist7, attlist8, attlist9,
-  element0, element1, element2, element3, element4, element5, element6,
-  element7,
+static PROLOG_HANDLER prolog0, prolog1, prolog2, doctype0, doctype1, doctype2,
+    doctype3, doctype4, doctype5, internalSubset, entity0, entity1, entity2,
+    entity3, entity4, entity5, entity6, entity7, entity8, entity9, entity10,
+    notation0, notation1, notation2, notation3, notation4, attlist0, attlist1,
+    attlist2, attlist3, attlist4, attlist5, attlist6, attlist7, attlist8,
+    attlist9, element0, element1, element2, element3, element4, element5,
+    element6, element7,
 #ifdef XML_DTD
-  externalSubset0, externalSubset1,
-  condSect0, condSect1, condSect2,
+    externalSubset0, externalSubset1, condSect0, condSect1, condSect2,
 #endif /* XML_DTD */
-  declClose,
-  error;
+    declClose, error;
 
 static int FASTCALL common(PROLOG_STATE *state, int tok);
 
 static int PTRCALL
-prolog0(PROLOG_STATE *state,
-        int tok,
-        const char *ptr,
-        const char *end,
-        const ENCODING *enc)
-{
+prolog0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     state->handler = prolog1;
@@ -169,10 +150,8 @@ prolog0(PROLOG_STATE *state,
   case XML_TOK_BOM:
     return XML_ROLE_NONE;
   case XML_TOK_DECL_OPEN:
-    if (!XmlNameMatchesAscii(enc,
-                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                             end,
-                             KW_DOCTYPE))
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
       break;
     state->handler = doctype0;
     return XML_ROLE_DOCTYPE_NONE;
@@ -184,12 +163,8 @@ prolog0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-prolog1(PROLOG_STATE *state,
-        int tok,
-        const char *ptr,
-        const char *end,
-        const ENCODING *enc)
-{
+prolog1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
@@ -207,10 +182,8 @@ prolog1(PROLOG_STATE *state,
      */
     return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
   case XML_TOK_DECL_OPEN:
-    if (!XmlNameMatchesAscii(enc,
-                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                             end,
-                             KW_DOCTYPE))
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
       break;
     state->handler = doctype0;
     return XML_ROLE_DOCTYPE_NONE;
@@ -222,12 +195,11 @@ prolog1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-prolog2(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+prolog2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
@@ -243,12 +215,11 @@ prolog2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype0(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+doctype0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -261,12 +232,8 @@ doctype0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype1(PROLOG_STATE *state,
-         int tok,
-         const char *ptr,
-         const char *end,
-         const ENCODING *enc)
-{
+doctype1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -291,12 +258,11 @@ doctype1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype2(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+doctype2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -308,12 +274,11 @@ doctype2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype3(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+doctype3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -325,12 +290,11 @@ doctype3(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype4(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+doctype4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -345,12 +309,11 @@ doctype4(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-doctype5(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+doctype5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_DOCTYPE_NONE;
@@ -362,40 +325,28 @@ doctype5(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-internalSubset(PROLOG_STATE *state,
-               int tok,
-               const char *ptr,
-               const char *end,
-               const ENCODING *enc)
-{
+internalSubset(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+               const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_DECL_OPEN:
-    if (XmlNameMatchesAscii(enc,
-                            ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
                             KW_ENTITY)) {
       state->handler = entity0;
       return XML_ROLE_ENTITY_NONE;
     }
-    if (XmlNameMatchesAscii(enc,
-                            ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
                             KW_ATTLIST)) {
       state->handler = attlist0;
       return XML_ROLE_ATTLIST_NONE;
     }
-    if (XmlNameMatchesAscii(enc,
-                            ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
                             KW_ELEMENT)) {
       state->handler = element0;
       return XML_ROLE_ELEMENT_NONE;
     }
-    if (XmlNameMatchesAscii(enc,
-                            ptr + 2 * MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
                             KW_NOTATION)) {
       state->handler = notation0;
       return XML_ROLE_NOTATION_NONE;
@@ -419,12 +370,8 @@ internalSubset(PROLOG_STATE *state,
 #ifdef XML_DTD
 
 static int PTRCALL
-externalSubset0(PROLOG_STATE *state,
-                int tok,
-                const char *ptr,
-                const char *end,
-                const ENCODING *enc)
-{
+externalSubset0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
   state->handler = externalSubset1;
   if (tok == XML_TOK_XML_DECL)
     return XML_ROLE_TEXT_DECL;
@@ -432,12 +379,8 @@ externalSubset0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-externalSubset1(PROLOG_STATE *state,
-                int tok,
-                const char *ptr,
-                const char *end,
-                const ENCODING *enc)
-{
+externalSubset1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_COND_SECT_OPEN:
     state->handler = condSect0;
@@ -464,12 +407,11 @@ externalSubset1(PROLOG_STATE *state,
 #endif /* XML_DTD */
 
 static int PTRCALL
-entity0(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -484,12 +426,11 @@ entity0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity1(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -501,12 +442,8 @@ entity1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity2(PROLOG_STATE *state,
-        int tok,
-        const char *ptr,
-        const char *end,
-        const ENCODING *enc)
-{
+entity2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -529,12 +466,11 @@ entity2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity3(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -546,12 +482,11 @@ entity3(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity4(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -563,12 +498,8 @@ entity4(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity5(PROLOG_STATE *state,
-        int tok,
-        const char *ptr,
-        const char *end,
-        const ENCODING *enc)
-{
+entity5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -586,12 +517,11 @@ entity5(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity6(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -604,12 +534,8 @@ entity6(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity7(PROLOG_STATE *state,
-        int tok,
-        const char *ptr,
-        const char *end,
-        const ENCODING *enc)
-{
+entity7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -632,12 +558,11 @@ entity7(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity8(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -649,12 +574,11 @@ entity8(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity9(PROLOG_STATE *state,
-        int tok,
-        const char *UNUSED_P(ptr),
-        const char *UNUSED_P(end),
-        const ENCODING *UNUSED_P(enc))
-{
+entity9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -666,12 +590,11 @@ entity9(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-entity10(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+entity10(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ENTITY_NONE;
@@ -683,12 +606,11 @@ entity10(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-notation0(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+notation0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NOTATION_NONE;
@@ -700,12 +622,8 @@ notation0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-notation1(PROLOG_STATE *state,
-          int tok,
-          const char *ptr,
-          const char *end,
-          const ENCODING *enc)
-{
+notation1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NOTATION_NONE;
@@ -724,12 +642,11 @@ notation1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-notation2(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+notation2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NOTATION_NONE;
@@ -741,12 +658,11 @@ notation2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-notation3(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+notation3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NOTATION_NONE;
@@ -759,12 +675,11 @@ notation3(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-notation4(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+notation4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NOTATION_NONE;
@@ -780,12 +695,11 @@ notation4(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist0(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -798,12 +712,11 @@ attlist0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist1(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -819,34 +732,23 @@ attlist1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist2(PROLOG_STATE *state,
-         int tok,
-         const char *ptr,
-         const char *end,
-         const ENCODING *enc)
-{
+attlist2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
-  case XML_TOK_NAME:
-    {
-      static const char * const types[] = {
-        KW_CDATA,
-        KW_ID,
-        KW_IDREF,
-        KW_IDREFS,
-        KW_ENTITY,
-        KW_ENTITIES,
-        KW_NMTOKEN,
-        KW_NMTOKENS,
-      };
-      int i;
-      for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
-        if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
-          state->handler = attlist8;
-          return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
-        }
-    }
+  case XML_TOK_NAME: {
+    static const char *const types[] = {
+        KW_CDATA,  KW_ID,       KW_IDREF,   KW_IDREFS,
+        KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS,
+    };
+    int i;
+    for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++)
+      if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
+        state->handler = attlist8;
+        return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
+      }
+  }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
       state->handler = attlist5;
       return XML_ROLE_ATTLIST_NONE;
@@ -860,12 +762,11 @@ attlist2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist3(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -879,12 +780,11 @@ attlist3(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist4(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -899,12 +799,11 @@ attlist4(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist5(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -916,12 +815,11 @@ attlist5(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist6(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -933,12 +831,11 @@ attlist6(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist7(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -954,33 +851,23 @@ attlist7(PROLOG_STATE *state,
 
 /* default value */
 static int PTRCALL
-attlist8(PROLOG_STATE *state,
-         int tok,
-         const char *ptr,
-         const char *end,
-         const ENCODING *enc)
-{
+attlist8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
   case XML_TOK_POUND_NAME:
-    if (XmlNameMatchesAscii(enc,
-                            ptr + MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
                             KW_IMPLIED)) {
       state->handler = attlist1;
       return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
     }
-    if (XmlNameMatchesAscii(enc,
-                            ptr + MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
                             KW_REQUIRED)) {
       state->handler = attlist1;
       return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
     }
-    if (XmlNameMatchesAscii(enc,
-                            ptr + MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
                             KW_FIXED)) {
       state->handler = attlist9;
       return XML_ROLE_ATTLIST_NONE;
@@ -994,12 +881,11 @@ attlist8(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-attlist9(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+attlist9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ATTLIST_NONE;
@@ -1011,12 +897,11 @@ attlist9(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element0(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1029,12 +914,8 @@ element0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element1(PROLOG_STATE *state,
-         int tok,
-         const char *ptr,
-         const char *end,
-         const ENCODING *enc)
-{
+element1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1059,19 +940,13 @@ element1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element2(PROLOG_STATE *state,
-         int tok,
-         const char *ptr,
-         const char *end,
-         const ENCODING *enc)
-{
+element2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
   case XML_TOK_POUND_NAME:
-    if (XmlNameMatchesAscii(enc,
-                            ptr + MIN_BYTES_PER_CHAR(enc),
-                            end,
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
                             KW_PCDATA)) {
       state->handler = element3;
       return XML_ROLE_CONTENT_PCDATA;
@@ -1099,12 +974,11 @@ element2(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element3(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1124,12 +998,11 @@ element3(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element4(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1142,12 +1015,11 @@ element4(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element5(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1163,12 +1035,11 @@ element5(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element6(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1193,12 +1064,11 @@ element6(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-element7(PROLOG_STATE *state,
-         int tok,
-         const char *UNUSED_P(ptr),
-         const char *UNUSED_P(end),
-         const ENCODING *UNUSED_P(enc))
-{
+element7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_ELEMENT_NONE;
@@ -1243,12 +1113,8 @@ element7(PROLOG_STATE *state,
 #ifdef XML_DTD
 
 static int PTRCALL
-condSect0(PROLOG_STATE *state,
-          int tok,
-          const char *ptr,
-          const char *end,
-          const ENCODING *enc)
-{
+condSect0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
@@ -1267,12 +1133,11 @@ condSect0(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-condSect1(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+condSect1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
@@ -1285,12 +1150,11 @@ condSect1(PROLOG_STATE *state,
 }
 
 static int PTRCALL
-condSect2(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+condSect2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
@@ -1304,12 +1168,11 @@ condSect2(PROLOG_STATE *state,
 #endif /* XML_DTD */
 
 static int PTRCALL
-declClose(PROLOG_STATE *state,
-          int tok,
-          const char *UNUSED_P(ptr),
-          const char *UNUSED_P(end),
-          const ENCODING *UNUSED_P(enc))
-{
+declClose(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   switch (tok) {
   case XML_TOK_PROLOG_S:
     return state->role_none;
@@ -1341,21 +1204,21 @@ declClose(PROLOG_STATE *state,
  * LCOV_EXCL_START
  */
 static int PTRCALL
-error(PROLOG_STATE *UNUSED_P(state),
-      int UNUSED_P(tok),
-      const char *UNUSED_P(ptr),
-      const char *UNUSED_P(end),
-      const ENCODING *UNUSED_P(enc))
-{
+error(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+      const ENCODING *enc) {
+  UNUSED_P(state);
+  UNUSED_P(tok);
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
   return XML_ROLE_NONE;
 }
 /* LCOV_EXCL_STOP */
 
 static int FASTCALL
-common(PROLOG_STATE *state, int tok)
-{
+common(PROLOG_STATE *state, int tok) {
 #ifdef XML_DTD
-  if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
+  if (! state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
     return XML_ROLE_INNER_PARAM_ENTITY_REF;
 #endif
   state->handler = error;
@@ -1363,8 +1226,7 @@ common(PROLOG_STATE *state, int tok)
 }
 
 void
-XmlPrologStateInit(PROLOG_STATE *state)
-{
+XmlPrologStateInit(PROLOG_STATE *state) {
   state->handler = prolog0;
 #ifdef XML_DTD
   state->documentEntity = 1;
@@ -1376,8 +1238,7 @@ XmlPrologStateInit(PROLOG_STATE *state)
 #ifdef XML_DTD
 
 void
-XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
-{
+XmlPrologStateInitExternalEntity(PROLOG_STATE *state) {
   state->handler = externalSubset0;
   state->documentEntity = 0;
   state->includeLevel = 0;
diff --git a/contrib/expat/lib/xmlrole.h b/contrib/expat/lib/xmlrole.h
index e5f048eab55c..036aba64fd29 100644
--- a/contrib/expat/lib/xmlrole.h
+++ b/contrib/expat/lib/xmlrole.h
@@ -36,7 +36,7 @@
 #ifdef __VMS
 /*      0        1         2         3      0        1         2         3
         1234567890123456789012345678901     1234567890123456789012345678901 */
-#define XmlPrologStateInitExternalEntity    XmlPrologStateInitExternalEnt
+#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
 #endif
 
 #include "xmltok.h"
@@ -113,11 +113,8 @@ enum {
 };
 
 typedef struct prolog_state {
-  int (PTRCALL *handler) (struct prolog_state *state,
-                          int tok,
-                          const char *ptr,
-                          const char *end,
-                          const ENCODING *enc);
+  int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
+                        const char *end, const ENCODING *enc);
   unsigned level;
   int role_none;
 #ifdef XML_DTD
@@ -132,8 +129,8 @@ void XmlPrologStateInit(PROLOG_STATE *);
 void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
 #endif /* XML_DTD */
 
-#define XmlTokenRole(state, tok, ptr, end, enc) \
- (((state)->handler)(state, tok, ptr, end, enc))
+#define XmlTokenRole(state, tok, ptr, end, enc)                                \
+  (((state)->handler)(state, tok, ptr, end, enc))
 
 #ifdef __cplusplus
 }
diff --git a/contrib/expat/lib/xmltok.c b/contrib/expat/lib/xmltok.c
index 6b415d83972c..11e9d1ccdad4 100644
--- a/contrib/expat/lib/xmltok.c
+++ b/contrib/expat/lib/xmltok.c
@@ -31,24 +31,23 @@
 */
 
 #include <stddef.h>
-#include <string.h>  /* memcpy */
+#include <string.h> /* memcpy */
 
 #if defined(_MSC_VER) && (_MSC_VER <= 1700)
-  /* for vs2012/11.0/1700 and earlier Visual Studio compilers */
-# define bool   int
-# define false  0
-# define true   1
+/* for vs2012/11.0/1700 and earlier Visual Studio compilers */
+#  define bool int
+#  define false 0
+#  define true 1
 #else
-# include <stdbool.h>
+#  include <stdbool.h>
 #endif
 
-
 #ifdef _WIN32
-#include "winconfig.h"
+#  include "winconfig.h"
 #else
-#ifdef HAVE_EXPAT_CONFIG_H
-#include <expat_config.h>
-#endif
+#  ifdef HAVE_EXPAT_CONFIG_H
+#    include <expat_config.h>
+#  endif
 #endif /* ndef _WIN32 */
 
 #include "expat_external.h"
@@ -57,58 +56,49 @@
 #include "nametab.h"
 
 #ifdef XML_DTD
-#define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
+#  define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
 #else
-#define IGNORE_SECTION_TOK_VTABLE /* as nothing */
+#  define IGNORE_SECTION_TOK_VTABLE /* as nothing */
 #endif
 
-#define VTABLE1 \
-  { PREFIX(prologTok), PREFIX(contentTok), \
-    PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE }, \
-  { PREFIX(attributeValueTok), PREFIX(entityValueTok) }, \
-  PREFIX(nameMatchesAscii), \
-  PREFIX(nameLength), \
-  PREFIX(skipS), \
-  PREFIX(getAtts), \
-  PREFIX(charRefNumber), \
-  PREFIX(predefinedEntityName), \
-  PREFIX(updatePosition), \
-  PREFIX(isPublicId)
+#define VTABLE1                                                                \
+  {PREFIX(prologTok), PREFIX(contentTok),                                      \
+   PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE},                         \
+      {PREFIX(attributeValueTok), PREFIX(entityValueTok)},                     \
+      PREFIX(nameMatchesAscii), PREFIX(nameLength), PREFIX(skipS),             \
+      PREFIX(getAtts), PREFIX(charRefNumber), PREFIX(predefinedEntityName),    \
+      PREFIX(updatePosition), PREFIX(isPublicId)
 
 #define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
 
-#define UCS2_GET_NAMING(pages, hi, lo) \
-   (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo) & 0x1F)))
+#define UCS2_GET_NAMING(pages, hi, lo)                                         \
+  (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo)&0x1F)))
 
 /* A 2 byte UTF-8 representation splits the characters 11 bits between
    the bottom 5 and 6 bits of the bytes.  We need 8 bits to index into
    pages, 3 bits to add to that index and 5 bits to generate the mask.
 */
-#define UTF8_GET_NAMING2(pages, byte) \
-    (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
-                      + ((((byte)[0]) & 3) << 1) \
-                      + ((((byte)[1]) >> 5) & 1)] \
-         & (1u << (((byte)[1]) & 0x1F)))
+#define UTF8_GET_NAMING2(pages, byte)                                          \
+  (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3)                         \
+                + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)]         \
+   & (1u << (((byte)[1]) & 0x1F)))
 
 /* A 3 byte UTF-8 representation splits the characters 16 bits between
    the bottom 4, 6 and 6 bits of the bytes.  We need 8 bits to index
    into pages, 3 bits to add to that index and 5 bits to generate the
    mask.
 */
-#define UTF8_GET_NAMING3(pages, byte) \
-  (namingBitmap[((pages)[((((byte)[0]) & 0xF) << 4) \
-                             + ((((byte)[1]) >> 2) & 0xF)] \
-                       << 3) \
-                      + ((((byte)[1]) & 3) << 1) \
-                      + ((((byte)[2]) >> 5) & 1)] \
-         & (1u << (((byte)[2]) & 0x1F)))
-
-#define UTF8_GET_NAMING(pages, p, n) \
-  ((n) == 2 \
-  ? UTF8_GET_NAMING2(pages, (const unsigned char *)(p)) \
-  : ((n) == 3 \
-     ? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) \
-     : 0))
+#define UTF8_GET_NAMING3(pages, byte)                                          \
+  (namingBitmap                                                                \
+       [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)]      \
+         << 3)                                                                 \
+        + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)]                 \
+   & (1u << (((byte)[2]) & 0x1F)))
+
+#define UTF8_GET_NAMING(pages, p, n)                                           \
+  ((n) == 2                                                                    \
+       ? UTF8_GET_NAMING2(pages, (const unsigned char *)(p))                   \
+       : ((n) == 3 ? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) : 0))
 
 /* Detection of invalid UTF-8 sequences is based on Table 3.1B
    of Unicode 3.2: http://www.unicode.org/unicode/reports/tr28/
@@ -120,88 +110,76 @@
      (A & 0xC0) == 0xC0  means A > 0xBF
 */
 
-#define UTF8_INVALID2(p) \
+#define UTF8_INVALID2(p)                                                       \
   ((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0)
 
-#define UTF8_INVALID3(p) \
-  (((p)[2] & 0x80) == 0 \
-  || \
-  ((*p) == 0xEF && (p)[1] == 0xBF \
-    ? \
-    (p)[2] > 0xBD \
-    : \
-    ((p)[2] & 0xC0) == 0xC0) \
-  || \
-  ((*p) == 0xE0 \
-    ? \
-    (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0 \
-    : \
-    ((p)[1] & 0x80) == 0 \
-    || \
-    ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
-
-#define UTF8_INVALID4(p) \
-  (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 \
-  || \
-  ((p)[2] & 0x80) == 0 || ((p)[2] & 0xC0) == 0xC0 \
-  || \
-  ((*p) == 0xF0 \
-    ? \
-    (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0 \
-    : \
-    ((p)[1] & 0x80) == 0 \
-    || \
-    ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
+#define UTF8_INVALID3(p)                                                       \
+  (((p)[2] & 0x80) == 0                                                        \
+   || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD                          \
+                                      : ((p)[2] & 0xC0) == 0xC0)               \
+   || ((*p) == 0xE0                                                            \
+           ? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
+
+#define UTF8_INVALID4(p)                                                       \
+  (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0     \
+   || ((p)[2] & 0xC0) == 0xC0                                                  \
+   || ((*p) == 0xF0                                                            \
+           ? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
 
 static int PTRFASTCALL
-isNever(const ENCODING *UNUSED_P(enc), const char *UNUSED_P(p))
-{
+isNever(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  UNUSED_P(p);
   return 0;
 }
 
 static int PTRFASTCALL
-utf8_isName2(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isName2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
 }
 
 static int PTRFASTCALL
-utf8_isName3(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isName3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
 }
 
 #define utf8_isName4 isNever
 
 static int PTRFASTCALL
-utf8_isNmstrt2(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isNmstrt2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
 }
 
 static int PTRFASTCALL
-utf8_isNmstrt3(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isNmstrt3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
 }
 
 #define utf8_isNmstrt4 isNever
 
 static int PTRFASTCALL
-utf8_isInvalid2(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isInvalid2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_INVALID2((const unsigned char *)p);
 }
 
 static int PTRFASTCALL
-utf8_isInvalid3(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isInvalid3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_INVALID3((const unsigned char *)p);
 }
 
 static int PTRFASTCALL
-utf8_isInvalid4(const ENCODING *UNUSED_P(enc), const char *p)
-{
+utf8_isInvalid4(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return UTF8_INVALID4((const unsigned char *)p);
 }
 
@@ -209,61 +187,44 @@ struct normal_encoding {
   ENCODING enc;
   unsigned char type[256];
 #ifdef XML_MIN_SIZE
-  int (PTRFASTCALL *byteType)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
-  int (PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
-  int (PTRCALL *charMatches)(const ENCODING *, const char *, int);
+  int(PTRFASTCALL *byteType)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
+  int(PTRCALL *charMatches)(const ENCODING *, const char *, int);
 #endif /* XML_MIN_SIZE */
-  int (PTRFASTCALL *isName2)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isName3)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isName4)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
-  int (PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
 };
 
-#define AS_NORMAL_ENCODING(enc)   ((const struct normal_encoding *) (enc))
+#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc))
 
 #ifdef XML_MIN_SIZE
 
-#define STANDARD_VTABLE(E) \
- E ## byteType, \
- E ## isNameMin, \
- E ## isNmstrtMin, \
- E ## byteToAscii, \
- E ## charMatches,
+#  define STANDARD_VTABLE(E)                                                   \
+    E##byteType, E##isNameMin, E##isNmstrtMin, E##byteToAscii, E##charMatches,
 
 #else
 
-#define STANDARD_VTABLE(E) /* as nothing */
+#  define STANDARD_VTABLE(E) /* as nothing */
 
 #endif
 
-#define NORMAL_VTABLE(E) \
- E ## isName2, \
- E ## isName3, \
- E ## isName4, \
- E ## isNmstrt2, \
- E ## isNmstrt3, \
- E ## isNmstrt4, \
- E ## isInvalid2, \
- E ## isInvalid3, \
- E ## isInvalid4
-
-#define NULL_VTABLE \
- /* isName2 */ NULL, \
- /* isName3 */ NULL, \
- /* isName4 */ NULL, \
- /* isNmstrt2 */ NULL, \
- /* isNmstrt3 */ NULL, \
- /* isNmstrt4 */ NULL, \
- /* isInvalid2 */ NULL, \
- /* isInvalid3 */ NULL, \
- /* isInvalid4 */ NULL
+#define NORMAL_VTABLE(E)                                                       \
+  E##isName2, E##isName3, E##isName4, E##isNmstrt2, E##isNmstrt3,              \
+      E##isNmstrt4, E##isInvalid2, E##isInvalid3, E##isInvalid4
+
+#define NULL_VTABLE                                                            \
+  /* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL,                  \
+      /* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL,        \
+      /* isInvalid2 */ NULL, /* isInvalid3 */ NULL, /* isInvalid4 */ NULL
 
 static int FASTCALL checkCharRefNumber(int);
 
@@ -271,75 +232,70 @@ static int FASTCALL checkCharRefNumber(int);
 #include "ascii.h"
 
 #ifdef XML_MIN_SIZE
-#define sb_isNameMin isNever
-#define sb_isNmstrtMin isNever
+#  define sb_isNameMin isNever
+#  define sb_isNmstrtMin isNever
 #endif
 
 #ifdef XML_MIN_SIZE
-#define MINBPC(enc) ((enc)->minBytesPerChar)
+#  define MINBPC(enc) ((enc)->minBytesPerChar)
 #else
 /* minimum bytes per character */
-#define MINBPC(enc) 1
+#  define MINBPC(enc) 1
 #endif
 
-#define SB_BYTE_TYPE(enc, p) \
+#define SB_BYTE_TYPE(enc, p)                                                   \
   (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
 
 #ifdef XML_MIN_SIZE
 static int PTRFASTCALL
-sb_byteType(const ENCODING *enc, const char *p)
-{
+sb_byteType(const ENCODING *enc, const char *p) {
   return SB_BYTE_TYPE(enc, p);
 }
-#define BYTE_TYPE(enc, p) \
- (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
+#  define BYTE_TYPE(enc, p) (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
 #else
-#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
+#  define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
 #endif
 
 #ifdef XML_MIN_SIZE
-#define BYTE_TO_ASCII(enc, p) \
- (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
+#  define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
 static int PTRFASTCALL
-sb_byteToAscii(const ENCODING *enc, const char *p)
-{
+sb_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
   return *p;
 }
 #else
-#define BYTE_TO_ASCII(enc, p) (*(p))
+#  define BYTE_TO_ASCII(enc, p) (*(p))
 #endif
 
-#define IS_NAME_CHAR(enc, p, n) \
- (AS_NORMAL_ENCODING(enc)->isName ## n(enc, p))
-#define IS_NMSTRT_CHAR(enc, p, n) \
- (AS_NORMAL_ENCODING(enc)->isNmstrt ## n(enc, p))
-#define IS_INVALID_CHAR(enc, p, n) \
- (AS_NORMAL_ENCODING(enc)->isInvalid ## n(enc, p))
+#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p))
+#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p))
+#define IS_INVALID_CHAR(enc, p, n)                                             \
+  (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
 
 #ifdef XML_MIN_SIZE
-#define IS_NAME_CHAR_MINBPC(enc, p) \
- (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
-#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
- (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
+#  define IS_NAME_CHAR_MINBPC(enc, p)                                          \
+    (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p)                                        \
+    (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
 #else
-#define IS_NAME_CHAR_MINBPC(enc, p) (0)
-#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
+#  define IS_NAME_CHAR_MINBPC(enc, p) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
 #endif
 
 #ifdef XML_MIN_SIZE
-#define CHAR_MATCHES(enc, p, c) \
- (AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
+#  define CHAR_MATCHES(enc, p, c)                                              \
+    (AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
 static int PTRCALL
-sb_charMatches(const ENCODING *enc, const char *p, int c)
-{
+sb_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
   return *p == c;
 }
 #else
 /* c is an ASCII character */
-#define CHAR_MATCHES(enc, p, c) (*(p) == c)
+#  define CHAR_MATCHES(enc, p, c) (*(p) == c)
 #endif
 
-#define PREFIX(ident) normal_ ## ident
+#define PREFIX(ident) normal_##ident
 #define XML_TOK_IMPL_C
 #include "xmltok_impl.c"
 #undef XML_TOK_IMPL_C
@@ -354,42 +310,46 @@ sb_charMatches(const ENCODING *enc, const char *p, int c)
 #undef IS_NMSTRT_CHAR_MINBPC
 #undef IS_INVALID_CHAR
 
-enum {  /* UTF8_cvalN is value of masked first byte of N byte sequence */
-  UTF8_cval1 = 0x00,
-  UTF8_cval2 = 0xc0,
-  UTF8_cval3 = 0xe0,
-  UTF8_cval4 = 0xf0
+enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
+       UTF8_cval1 = 0x00,
+       UTF8_cval2 = 0xc0,
+       UTF8_cval3 = 0xe0,
+       UTF8_cval4 = 0xf0
 };
 
 void
-_INTERNAL_trim_to_complete_utf8_characters(const char * from, const char ** fromLimRef)
-{
-  const char * fromLim = *fromLimRef;
+_INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                           const char **fromLimRef) {
+  const char *fromLim = *fromLimRef;
   size_t walked = 0;
   for (; fromLim > from; fromLim--, walked++) {
     const unsigned char prev = (unsigned char)fromLim[-1];
-    if ((prev & 0xf8u) == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
+    if ((prev & 0xf8u)
+        == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
       if (walked + 1 >= 4) {
         fromLim += 4 - 1;
         break;
       } else {
         walked = 0;
       }
-    } else if ((prev & 0xf0u) == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
+    } else if ((prev & 0xf0u)
+               == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
       if (walked + 1 >= 3) {
         fromLim += 3 - 1;
         break;
       } else {
         walked = 0;
       }
-    } else if ((prev & 0xe0u) == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
+    } else if ((prev & 0xe0u)
+               == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
       if (walked + 1 >= 2) {
         fromLim += 2 - 1;
         break;
       } else {
         walked = 0;
       }
-    } else if ((prev & 0x80u) == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
+    } else if ((prev & 0x80u)
+               == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
       break;
     }
   }
@@ -397,16 +357,15 @@ _INTERNAL_trim_to_complete_utf8_characters(const char * from, const char ** from
 }
 
 static enum XML_Convert_Result PTRCALL
-utf8_toUtf8(const ENCODING *UNUSED_P(enc),
-            const char **fromP, const char *fromLim,
-            char **toP, const char *toLim)
-{
+utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+            char **toP, const char *toLim) {
   bool input_incomplete = false;
   bool output_exhausted = false;
 
   /* Avoid copying partial characters (due to limited space). */
   const ptrdiff_t bytesAvailable = fromLim - *fromP;
   const ptrdiff_t bytesStorable = toLim - *toP;
+  UNUSED_P(enc);
   if (bytesAvailable > bytesStorable) {
     fromLim = *fromP + bytesStorable;
     output_exhausted = true;
@@ -414,7 +373,7 @@ utf8_toUtf8(const ENCODING *UNUSED_P(enc),
 
   /* Avoid copying partial characters (from incomplete input). */
   {
-    const char * const fromLimBefore = fromLim;
+    const char *const fromLimBefore = fromLim;
     _INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim);
     if (fromLim < fromLimBefore) {
       input_incomplete = true;
@@ -428,7 +387,7 @@ utf8_toUtf8(const ENCODING *UNUSED_P(enc),
     *toP += bytesToCopy;
   }
 
-  if (output_exhausted)  /* needs to go first */
+  if (output_exhausted) /* needs to go first */
     return XML_CONVERT_OUTPUT_EXHAUSTED;
   else if (input_incomplete)
     return XML_CONVERT_INPUT_INCOMPLETE;
@@ -437,10 +396,8 @@ utf8_toUtf8(const ENCODING *UNUSED_P(enc),
 }
 
 static enum XML_Convert_Result PTRCALL
-utf8_toUtf16(const ENCODING *enc,
-             const char **fromP, const char *fromLim,
-             unsigned short **toP, const unsigned short *toLim)
-{
+utf8_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+             unsigned short **toP, const unsigned short *toLim) {
   enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
   unsigned short *to = *toP;
   const char *from = *fromP;
@@ -459,30 +416,28 @@ utf8_toUtf16(const ENCODING *enc,
         res = XML_CONVERT_INPUT_INCOMPLETE;
         goto after;
       }
-      *to++ = (unsigned short)(((from[0] & 0xf) << 12)
-                               | ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
+      *to++ = (unsigned short)(((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6)
+                               | (from[2] & 0x3f));
       from += 3;
       break;
-    case BT_LEAD4:
-      {
-        unsigned long n;
-        if (toLim - to < 2) {
-          res = XML_CONVERT_OUTPUT_EXHAUSTED;
-          goto after;
-        }
-        if (fromLim - from < 4) {
-          res = XML_CONVERT_INPUT_INCOMPLETE;
-          goto after;
-        }
-        n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
-            | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
-        n -= 0x10000;
-        to[0] = (unsigned short)((n >> 10) | 0xD800);
-        to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
-        to += 2;
-        from += 4;
+    case BT_LEAD4: {
+      unsigned long n;
+      if (toLim - to < 2) {
+        res = XML_CONVERT_OUTPUT_EXHAUSTED;
+        goto after;
       }
-      break;
+      if (fromLim - from < 4) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
+          | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
+      n -= 0x10000;
+      to[0] = (unsigned short)((n >> 10) | 0xD800);
+      to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
+      to += 2;
+      from += 4;
+    } break;
     default:
       *to++ = *from++;
       break;
@@ -497,56 +452,51 @@ after:
 }
 
 #ifdef XML_NS
-static const struct normal_encoding utf8_encoding_ns = {
-  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
-  {
-#include "asciitab.h"
-#include "utf8tab.h"
-  },
-  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
-};
+static const struct normal_encoding utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
 #endif
 
-static const struct normal_encoding utf8_encoding = {
-  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
-  {
+static const struct normal_encoding utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
 #define BT_COLON BT_NMSTRT
 #include "asciitab.h"
 #undef BT_COLON
 #include "utf8tab.h"
-  },
-  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
-};
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
 
 #ifdef XML_NS
 
-static const struct normal_encoding internal_utf8_encoding_ns = {
-  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
-  {
-#include "iasciitab.h"
-#include "utf8tab.h"
-  },
-  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
-};
+static const struct normal_encoding internal_utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "iasciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
 
 #endif
 
-static const struct normal_encoding internal_utf8_encoding = {
-  { VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
-  {
+static const struct normal_encoding internal_utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
 #define BT_COLON BT_NMSTRT
 #include "iasciitab.h"
 #undef BT_COLON
 #include "utf8tab.h"
-  },
-  STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
-};
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
 
 static enum XML_Convert_Result PTRCALL
-latin1_toUtf8(const ENCODING *UNUSED_P(enc),
-              const char **fromP, const char *fromLim,
-              char **toP, const char *toLim)
-{
+latin1_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+              char **toP, const char *toLim) {
+  UNUSED_P(enc);
   for (;;) {
     unsigned char c;
     if (*fromP == fromLim)
@@ -558,8 +508,7 @@ latin1_toUtf8(const ENCODING *UNUSED_P(enc),
       *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
       *(*toP)++ = (char)((c & 0x3f) | 0x80);
       (*fromP)++;
-    }
-    else {
+    } else {
       if (*toP == toLim)
         return XML_CONVERT_OUTPUT_EXHAUSTED;
       *(*toP)++ = *(*fromP)++;
@@ -568,10 +517,9 @@ latin1_toUtf8(const ENCODING *UNUSED_P(enc),
 }
 
 static enum XML_Convert_Result PTRCALL
-latin1_toUtf16(const ENCODING *UNUSED_P(enc),
-               const char **fromP, const char *fromLim,
-               unsigned short **toP, const unsigned short *toLim)
-{
+latin1_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+               unsigned short **toP, const unsigned short *toLim) {
+  UNUSED_P(enc);
   while (*fromP < fromLim && *toP < toLim)
     *(*toP)++ = (unsigned char)*(*fromP)++;
 
@@ -583,33 +531,30 @@ latin1_toUtf16(const ENCODING *UNUSED_P(enc),
 
 #ifdef XML_NS
 
-static const struct normal_encoding latin1_encoding_ns = {
-  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
-  {
-#include "asciitab.h"
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(sb_) NULL_VTABLE
-};
+static const struct normal_encoding latin1_encoding_ns
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
 
 #endif
 
-static const struct normal_encoding latin1_encoding = {
-  { VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
-  {
+static const struct normal_encoding latin1_encoding
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
 #define BT_COLON BT_NMSTRT
 #include "asciitab.h"
 #undef BT_COLON
 #include "latin1tab.h"
-  },
-  STANDARD_VTABLE(sb_) NULL_VTABLE
-};
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
 
 static enum XML_Convert_Result PTRCALL
-ascii_toUtf8(const ENCODING *UNUSED_P(enc),
-             const char **fromP, const char *fromLim,
-             char **toP, const char *toLim)
-{
+ascii_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+             char **toP, const char *toLim) {
+  UNUSED_P(enc);
   while (*fromP < fromLim && *toP < toLim)
     *(*toP)++ = *(*fromP)++;
 
@@ -621,40 +566,45 @@ ascii_toUtf8(const ENCODING *UNUSED_P(enc),
 
 #ifdef XML_NS
 
-static const struct normal_encoding ascii_encoding_ns = {
-  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
-  {
-#include "asciitab.h"
-/* BT_NONXML == 0 */
-  },
-  STANDARD_VTABLE(sb_) NULL_VTABLE
-};
+static const struct normal_encoding ascii_encoding_ns
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
 
 #endif
 
-static const struct normal_encoding ascii_encoding = {
-  { VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
-  {
+static const struct normal_encoding ascii_encoding
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
 #define BT_COLON BT_NMSTRT
 #include "asciitab.h"
 #undef BT_COLON
-/* BT_NONXML == 0 */
-  },
-  STANDARD_VTABLE(sb_) NULL_VTABLE
-};
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
 
 static int PTRFASTCALL
-unicode_byte_type(char hi, char lo)
-{
+unicode_byte_type(char hi, char lo) {
   switch ((unsigned char)hi) {
-  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
+  /* 0xD800–0xDBFF first 16-bit code unit or high surrogate (W1) */
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
     return BT_LEAD4;
-  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
+  /* 0xDC00–0xDFFF second 16-bit code unit or low surrogate (W2) */
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
     return BT_TRAIL;
   case 0xFF:
     switch ((unsigned char)lo) {
-    case 0xFF:
-    case 0xFE:
+    case 0xFF: /* noncharacter-FFFF */
+    case 0xFE: /* noncharacter-FFFE */
       return BT_NONXML;
     }
     break;
@@ -662,102 +612,105 @@ unicode_byte_type(char hi, char lo)
   return BT_NONASCII;
 }
 
-#define DEFINE_UTF16_TO_UTF8(E) \
-static enum XML_Convert_Result  PTRCALL \
-E ## toUtf8(const ENCODING *UNUSED_P(enc), \
-            const char **fromP, const char *fromLim, \
-            char **toP, const char *toLim) \
-{ \
-  const char *from = *fromP; \
-  fromLim = from + (((fromLim - from) >> 1) << 1);  /* shrink to even */ \
-  for (; from < fromLim; from += 2) { \
-    int plane; \
-    unsigned char lo2; \
-    unsigned char lo = GET_LO(from); \
-    unsigned char hi = GET_HI(from); \
-    switch (hi) { \
-    case 0: \
-      if (lo < 0x80) { \
-        if (*toP == toLim) { \
-          *fromP = from; \
-          return XML_CONVERT_OUTPUT_EXHAUSTED; \
-        } \
-        *(*toP)++ = lo; \
-        break; \
-      } \
-      /* fall through */ \
-    case 0x1: case 0x2: case 0x3: \
-    case 0x4: case 0x5: case 0x6: case 0x7: \
-      if (toLim -  *toP < 2) { \
-        *fromP = from; \
-        return XML_CONVERT_OUTPUT_EXHAUSTED; \
-      } \
-      *(*toP)++ = ((lo >> 6) | (hi << 2) |  UTF8_cval2); \
-      *(*toP)++ = ((lo & 0x3f) | 0x80); \
-      break; \
-    default: \
-      if (toLim -  *toP < 3)  { \
-        *fromP = from; \
-        return XML_CONVERT_OUTPUT_EXHAUSTED; \
-      } \
-      /* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
-      *(*toP)++ = ((hi >> 4) | UTF8_cval3); \
-      *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
-      *(*toP)++ = ((lo & 0x3f) | 0x80); \
-      break; \
-    case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
-      if (toLim -  *toP < 4) { \
-        *fromP = from; \
-        return XML_CONVERT_OUTPUT_EXHAUSTED; \
-      } \
-      if (fromLim - from < 4) { \
-        *fromP = from; \
-        return XML_CONVERT_INPUT_INCOMPLETE; \
-      } \
-      plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
-      *(*toP)++ = ((plane >> 2) | UTF8_cval4); \
-      *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
-      from += 2; \
-      lo2 = GET_LO(from); \
-      *(*toP)++ = (((lo & 0x3) << 4) \
-                   | ((GET_HI(from) & 0x3) << 2) \
-                   | (lo2 >> 6) \
-                   | 0x80); \
-      *(*toP)++ = ((lo2 & 0x3f) | 0x80); \
-      break; \
-    } \
-  } \
-  *fromP = from; \
-  if (from < fromLim) \
-    return XML_CONVERT_INPUT_INCOMPLETE; \
-  else \
-    return XML_CONVERT_COMPLETED; \
-}
+#define DEFINE_UTF16_TO_UTF8(E)                                                \
+  static enum XML_Convert_Result PTRCALL E##toUtf8(                            \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      char **toP, const char *toLim) {                                         \
+    const char *from = *fromP;                                                 \
+    UNUSED_P(enc);                                                             \
+    fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */      \
+    for (; from < fromLim; from += 2) {                                        \
+      int plane;                                                               \
+      unsigned char lo2;                                                       \
+      unsigned char lo = GET_LO(from);                                         \
+      unsigned char hi = GET_HI(from);                                         \
+      switch (hi) {                                                            \
+      case 0:                                                                  \
+        if (lo < 0x80) {                                                       \
+          if (*toP == toLim) {                                                 \
+            *fromP = from;                                                     \
+            return XML_CONVERT_OUTPUT_EXHAUSTED;                               \
+          }                                                                    \
+          *(*toP)++ = lo;                                                      \
+          break;                                                               \
+        }                                                                      \
+        /* fall through */                                                     \
+      case 0x1:                                                                \
+      case 0x2:                                                                \
+      case 0x3:                                                                \
+      case 0x4:                                                                \
+      case 0x5:                                                                \
+      case 0x6:                                                                \
+      case 0x7:                                                                \
+        if (toLim - *toP < 2) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2);                      \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      default:                                                                 \
+        if (toLim - *toP < 3) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        /* 16 bits divided 4, 6, 6 amongst 3 bytes */                          \
+        *(*toP)++ = ((hi >> 4) | UTF8_cval3);                                  \
+        *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80);                    \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      case 0xD8:                                                               \
+      case 0xD9:                                                               \
+      case 0xDA:                                                               \
+      case 0xDB:                                                               \
+        if (toLim - *toP < 4) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        if (fromLim - from < 4) {                                              \
+          *fromP = from;                                                       \
+          return XML_CONVERT_INPUT_INCOMPLETE;                                 \
+        }                                                                      \
+        plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1;                   \
+        *(*toP)++ = (char)((plane >> 2) | UTF8_cval4);                         \
+        *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80);         \
+        from += 2;                                                             \
+        lo2 = GET_LO(from);                                                    \
+        *(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2)           \
+                     | (lo2 >> 6) | 0x80);                                     \
+        *(*toP)++ = ((lo2 & 0x3f) | 0x80);                                     \
+        break;                                                                 \
+      }                                                                        \
+    }                                                                          \
+    *fromP = from;                                                             \
+    if (from < fromLim)                                                        \
+      return XML_CONVERT_INPUT_INCOMPLETE;                                     \
+    else                                                                       \
+      return XML_CONVERT_COMPLETED;                                            \
+  }
 
-#define DEFINE_UTF16_TO_UTF16(E) \
-static enum XML_Convert_Result  PTRCALL \
-E ## toUtf16(const ENCODING *UNUSED_P(enc), \
-             const char **fromP, const char *fromLim, \
-             unsigned short **toP, const unsigned short *toLim) \
-{ \
-  enum XML_Convert_Result res = XML_CONVERT_COMPLETED; \
-  fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1);  /* shrink to even */ \
-  /* Avoid copying first half only of surrogate */ \
-  if (fromLim - *fromP > ((toLim - *toP) << 1) \
-      && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) { \
-    fromLim -= 2; \
-    res = XML_CONVERT_INPUT_INCOMPLETE; \
-  } \
-  for (; *fromP < fromLim && *toP < toLim; *fromP += 2) \
-    *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
-  if ((*toP == toLim) && (*fromP < fromLim)) \
-    return XML_CONVERT_OUTPUT_EXHAUSTED; \
-  else \
-    return res; \
-}
+#define DEFINE_UTF16_TO_UTF16(E)                                               \
+  static enum XML_Convert_Result PTRCALL E##toUtf16(                           \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      unsigned short **toP, const unsigned short *toLim) {                     \
+    enum XML_Convert_Result res = XML_CONVERT_COMPLETED;                       \
+    UNUSED_P(enc);                                                             \
+    fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */  \
+    /* Avoid copying first half only of surrogate */                           \
+    if (fromLim - *fromP > ((toLim - *toP) << 1)                               \
+        && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) {                             \
+      fromLim -= 2;                                                            \
+      res = XML_CONVERT_INPUT_INCOMPLETE;                                      \
+    }                                                                          \
+    for (; *fromP < fromLim && *toP < toLim; *fromP += 2)                      \
+      *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP);                      \
+    if ((*toP == toLim) && (*fromP < fromLim))                                 \
+      return XML_CONVERT_OUTPUT_EXHAUSTED;                                     \
+    else                                                                       \
+      return res;                                                              \
+  }
 
-#define SET2(ptr, ch) \
-  (((ptr)[0] = ((ch) & 0xff)), ((ptr)[1] = ((ch) >> 8)))
+#define SET2(ptr, ch) (((ptr)[0] = ((ch)&0xff)), ((ptr)[1] = ((ch) >> 8)))
 #define GET_LO(ptr) ((unsigned char)(ptr)[0])
 #define GET_HI(ptr) ((unsigned char)(ptr)[1])
 
@@ -768,8 +721,7 @@ DEFINE_UTF16_TO_UTF16(little2_)
 #undef GET_LO
 #undef GET_HI
 
-#define SET2(ptr, ch) \
-  (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch) & 0xFF)))
+#define SET2(ptr, ch) (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch)&0xFF)))
 #define GET_LO(ptr) ((unsigned char)(ptr)[1])
 #define GET_HI(ptr) ((unsigned char)(ptr)[0])
 
@@ -780,292 +732,279 @@ DEFINE_UTF16_TO_UTF16(big2_)
 #undef GET_LO
 #undef GET_HI
 
-#define LITTLE2_BYTE_TYPE(enc, p) \
- ((p)[1] == 0 \
-  ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \
-  : unicode_byte_type((p)[1], (p)[0]))
-#define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
-#define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
-#define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \
+#define LITTLE2_BYTE_TYPE(enc, p)                                              \
+  ((p)[1] == 0 ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)]  \
+               : unicode_byte_type((p)[1], (p)[0]))
+#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1)
+#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == c)
+#define LITTLE2_IS_NAME_CHAR_MINBPC(p)                                         \
   UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
-#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)                                       \
   UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
 
 #ifdef XML_MIN_SIZE
 
 static int PTRFASTCALL
-little2_byteType(const ENCODING *enc, const char *p)
-{
+little2_byteType(const ENCODING *enc, const char *p) {
   return LITTLE2_BYTE_TYPE(enc, p);
 }
 
 static int PTRFASTCALL
-little2_byteToAscii(const ENCODING *enc, const char *p)
-{
-  return LITTLE2_BYTE_TO_ASCII(enc, p);
+little2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_BYTE_TO_ASCII(p);
 }
 
 static int PTRCALL
-little2_charMatches(const ENCODING *enc, const char *p, int c)
-{
-  return LITTLE2_CHAR_MATCHES(enc, p, c);
+little2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return LITTLE2_CHAR_MATCHES(p, c);
 }
 
 static int PTRFASTCALL
-little2_isNameMin(const ENCODING *enc, const char *p)
-{
-  return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
+little2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NAME_CHAR_MINBPC(p);
 }
 
 static int PTRFASTCALL
-little2_isNmstrtMin(const ENCODING *enc, const char *p)
-{
-  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
+little2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
 }
 
-#undef VTABLE
-#define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
+#  undef VTABLE
+#  define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
 
 #else /* not XML_MIN_SIZE */
 
-#undef PREFIX
-#define PREFIX(ident) little2_ ## ident
-#define MINBPC(enc) 2
+#  undef PREFIX
+#  define PREFIX(ident) little2_##ident
+#  define MINBPC(enc) 2
 /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
-#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
-#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
-#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
-#define IS_NAME_CHAR(enc, p, n) 0
-#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
-#define IS_NMSTRT_CHAR(enc, p, n) (0)
-#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
-
-#define XML_TOK_IMPL_C
-#include "xmltok_impl.c"
-#undef XML_TOK_IMPL_C
-
-#undef MINBPC
-#undef BYTE_TYPE
-#undef BYTE_TO_ASCII
-#undef CHAR_MATCHES
-#undef IS_NAME_CHAR
-#undef IS_NAME_CHAR_MINBPC
-#undef IS_NMSTRT_CHAR
-#undef IS_NMSTRT_CHAR_MINBPC
-#undef IS_INVALID_CHAR
+#  define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
 
 #endif /* not XML_MIN_SIZE */
 
 #ifdef XML_NS
 
-static const struct normal_encoding little2_encoding_ns = {
-  { VTABLE, 2, 0,
-#if BYTEORDER == 1234
-    1
-#else
-    0
-#endif
-  },
-  {
-#include "asciitab.h"
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(little2_) NULL_VTABLE
-};
+static const struct normal_encoding little2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 1234
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
 
 #endif
 
-static const struct normal_encoding little2_encoding = {
-  { VTABLE, 2, 0,
+static const struct normal_encoding little2_encoding
+    = {{VTABLE, 2, 0,
 #if BYTEORDER == 1234
-    1
+        1
 #else
-    0
+        0
 #endif
-  },
-  {
+       },
+       {
 #define BT_COLON BT_NMSTRT
 #include "asciitab.h"
 #undef BT_COLON
 #include "latin1tab.h"
-  },
-  STANDARD_VTABLE(little2_) NULL_VTABLE
-};
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
 
 #if BYTEORDER != 4321
 
-#ifdef XML_NS
+#  ifdef XML_NS
 
-static const struct normal_encoding internal_little2_encoding_ns = {
-  { VTABLE, 2, 0, 1 },
-  {
-#include "iasciitab.h"
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(little2_) NULL_VTABLE
-};
+static const struct normal_encoding internal_little2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
 
-#endif
+#  endif
 
-static const struct normal_encoding internal_little2_encoding = {
-  { VTABLE, 2, 0, 1 },
-  {
-#define BT_COLON BT_NMSTRT
-#include "iasciitab.h"
-#undef BT_COLON
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(little2_) NULL_VTABLE
-};
+static const struct normal_encoding internal_little2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
 
 #endif
 
-
-#define BIG2_BYTE_TYPE(enc, p) \
- ((p)[0] == 0 \
-  ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
-  : unicode_byte_type((p)[0], (p)[1]))
-#define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
-#define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
-#define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \
+#define BIG2_BYTE_TYPE(enc, p)                                                 \
+  ((p)[0] == 0                                                                 \
+       ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]]        \
+       : unicode_byte_type((p)[0], (p)[1]))
+#define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (p)[1] : -1)
+#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == c)
+#define BIG2_IS_NAME_CHAR_MINBPC(p)                                            \
   UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
-#define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
+#define BIG2_IS_NMSTRT_CHAR_MINBPC(p)                                          \
   UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
 
 #ifdef XML_MIN_SIZE
 
 static int PTRFASTCALL
-big2_byteType(const ENCODING *enc, const char *p)
-{
+big2_byteType(const ENCODING *enc, const char *p) {
   return BIG2_BYTE_TYPE(enc, p);
 }
 
 static int PTRFASTCALL
-big2_byteToAscii(const ENCODING *enc, const char *p)
-{
-  return BIG2_BYTE_TO_ASCII(enc, p);
+big2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_BYTE_TO_ASCII(p);
 }
 
 static int PTRCALL
-big2_charMatches(const ENCODING *enc, const char *p, int c)
-{
-  return BIG2_CHAR_MATCHES(enc, p, c);
+big2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return BIG2_CHAR_MATCHES(p, c);
 }
 
 static int PTRFASTCALL
-big2_isNameMin(const ENCODING *enc, const char *p)
-{
-  return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
+big2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NAME_CHAR_MINBPC(p);
 }
 
 static int PTRFASTCALL
-big2_isNmstrtMin(const ENCODING *enc, const char *p)
-{
-  return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
+big2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
 }
 
-#undef VTABLE
-#define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
+#  undef VTABLE
+#  define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
 
 #else /* not XML_MIN_SIZE */
 
-#undef PREFIX
-#define PREFIX(ident) big2_ ## ident
-#define MINBPC(enc) 2
+#  undef PREFIX
+#  define PREFIX(ident) big2_##ident
+#  define MINBPC(enc) 2
 /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
-#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
-#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
-#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
-#define IS_NAME_CHAR(enc, p, n) 0
-#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
-#define IS_NMSTRT_CHAR(enc, p, n) (0)
-#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
-
-#define XML_TOK_IMPL_C
-#include "xmltok_impl.c"
-#undef XML_TOK_IMPL_C
-
-#undef MINBPC
-#undef BYTE_TYPE
-#undef BYTE_TO_ASCII
-#undef CHAR_MATCHES
-#undef IS_NAME_CHAR
-#undef IS_NAME_CHAR_MINBPC
-#undef IS_NMSTRT_CHAR
-#undef IS_NMSTRT_CHAR_MINBPC
-#undef IS_INVALID_CHAR
+#  define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
 
 #endif /* not XML_MIN_SIZE */
 
 #ifdef XML_NS
 
-static const struct normal_encoding big2_encoding_ns = {
-  { VTABLE, 2, 0,
-#if BYTEORDER == 4321
-  1
-#else
-  0
-#endif
-  },
-  {
-#include "asciitab.h"
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(big2_) NULL_VTABLE
-};
+static const struct normal_encoding big2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 4321
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
 
 #endif
 
-static const struct normal_encoding big2_encoding = {
-  { VTABLE, 2, 0,
+static const struct normal_encoding big2_encoding
+    = {{VTABLE, 2, 0,
 #if BYTEORDER == 4321
-  1
+        1
 #else
-  0
+        0
 #endif
-  },
-  {
+       },
+       {
 #define BT_COLON BT_NMSTRT
 #include "asciitab.h"
 #undef BT_COLON
 #include "latin1tab.h"
-  },
-  STANDARD_VTABLE(big2_) NULL_VTABLE
-};
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
 
 #if BYTEORDER != 1234
 
-#ifdef XML_NS
+#  ifdef XML_NS
 
-static const struct normal_encoding internal_big2_encoding_ns = {
-  { VTABLE, 2, 0, 1 },
-  {
-#include "iasciitab.h"
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(big2_) NULL_VTABLE
-};
+static const struct normal_encoding internal_big2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
 
-#endif
+#  endif
 
-static const struct normal_encoding internal_big2_encoding = {
-  { VTABLE, 2, 0, 1 },
-  {
-#define BT_COLON BT_NMSTRT
-#include "iasciitab.h"
-#undef BT_COLON
-#include "latin1tab.h"
-  },
-  STANDARD_VTABLE(big2_) NULL_VTABLE
-};
+static const struct normal_encoding internal_big2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
 
 #endif
 
 #undef PREFIX
 
 static int FASTCALL
-streqci(const char *s1, const char *s2)
-{
+streqci(const char *s1, const char *s2) {
   for (;;) {
     char c1 = *s1++;
     char c2 = *s2++;
@@ -1079,22 +1018,21 @@ streqci(const char *s1, const char *s2)
       c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
     if (c1 != c2)
       return 0;
-    if (!c1)
+    if (! c1)
       break;
   }
   return 1;
 }
 
 static void PTRCALL
-initUpdatePosition(const ENCODING *UNUSED_P(enc), const char *ptr,
-                   const char *end, POSITION *pos)
-{
+initUpdatePosition(const ENCODING *enc, const char *ptr, const char *end,
+                   POSITION *pos) {
+  UNUSED_P(enc);
   normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
 }
 
 static int
-toAscii(const ENCODING *enc, const char *ptr, const char *end)
-{
+toAscii(const ENCODING *enc, const char *ptr, const char *end) {
   char buf[1];
   char *p = buf;
   XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
@@ -1105,8 +1043,7 @@ toAscii(const ENCODING *enc, const char *ptr, const char *end)
 }
 
 static int FASTCALL
-isSpace(int c)
-{
+isSpace(int c) {
   switch (c) {
   case 0x20:
   case 0xD:
@@ -1121,21 +1058,16 @@ isSpace(int c)
    followed by name=val.
 */
 static int
-parsePseudoAttribute(const ENCODING *enc,
-                     const char *ptr,
-                     const char *end,
-                     const char **namePtr,
-                     const char **nameEndPtr,
-                     const char **valPtr,
-                     const char **nextTokPtr)
-{
+parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end,
+                     const char **namePtr, const char **nameEndPtr,
+                     const char **valPtr, const char **nextTokPtr) {
   int c;
   char open;
   if (ptr == end) {
     *namePtr = NULL;
     return 1;
   }
-  if (!isSpace(toAscii(enc, ptr, end))) {
+  if (! isSpace(toAscii(enc, ptr, end))) {
     *nextTokPtr = ptr;
     return 0;
   }
@@ -1191,12 +1123,9 @@ parsePseudoAttribute(const ENCODING *enc,
     c = toAscii(enc, ptr, end);
     if (c == open)
       break;
-    if (!(ASCII_a <= c && c <= ASCII_z)
-        && !(ASCII_A <= c && c <= ASCII_Z)
-        && !(ASCII_0 <= c && c <= ASCII_9)
-        && c != ASCII_PERIOD
-        && c != ASCII_MINUS
-        && c != ASCII_UNDERSCORE) {
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)
+        && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD
+        && c != ASCII_MINUS && c != ASCII_UNDERSCORE) {
       *nextTokPtr = ptr;
       return 0;
     }
@@ -1205,68 +1134,52 @@ parsePseudoAttribute(const ENCODING *enc,
   return 1;
 }
 
-static const char KW_version[] = {
-  ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'
-};
+static const char KW_version[]
+    = {ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'};
 
-static const char KW_encoding[] = {
-  ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d, ASCII_i, ASCII_n, ASCII_g, '\0'
-};
+static const char KW_encoding[] = {ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d,
+                                   ASCII_i, ASCII_n, ASCII_g, '\0'};
 
-static const char KW_standalone[] = {
-  ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a, ASCII_l, ASCII_o,
-  ASCII_n, ASCII_e, '\0'
-};
+static const char KW_standalone[]
+    = {ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a,
+       ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'};
 
-static const char KW_yes[] = {
-  ASCII_y, ASCII_e, ASCII_s,  '\0'
-};
+static const char KW_yes[] = {ASCII_y, ASCII_e, ASCII_s, '\0'};
 
-static const char KW_no[] = {
-  ASCII_n, ASCII_o,  '\0'
-};
+static const char KW_no[] = {ASCII_n, ASCII_o, '\0'};
 
 static int
-doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
-                                                 const char *,
+doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *,
                                                  const char *),
-               int isGeneralTextEntity,
-               const ENCODING *enc,
-               const char *ptr,
-               const char *end,
-               const char **badPtr,
-               const char **versionPtr,
-               const char **versionEndPtr,
-               const char **encodingName,
-               const ENCODING **encoding,
-               int *standalone)
-{
+               int isGeneralTextEntity, const ENCODING *enc, const char *ptr,
+               const char *end, const char **badPtr, const char **versionPtr,
+               const char **versionEndPtr, const char **encodingName,
+               const ENCODING **encoding, int *standalone) {
   const char *val = NULL;
   const char *name = NULL;
   const char *nameEnd = NULL;
   ptr += 5 * enc->minBytesPerChar;
   end -= 2 * enc->minBytesPerChar;
-  if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
-      || !name) {
+  if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
+      || ! name) {
     *badPtr = ptr;
     return 0;
   }
-  if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
-    if (!isGeneralTextEntity) {
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
+    if (! isGeneralTextEntity) {
       *badPtr = name;
       return 0;
     }
-  }
-  else {
+  } else {
     if (versionPtr)
       *versionPtr = val;
     if (versionEndPtr)
       *versionEndPtr = ptr;
-    if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
       *badPtr = ptr;
       return 0;
     }
-    if (!name) {
+    if (! name) {
       if (isGeneralTextEntity) {
         /* a TextDecl must have an EncodingDecl */
         *badPtr = ptr;
@@ -1277,7 +1190,7 @@ doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
   }
   if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
     int c = toAscii(enc, val, end);
-    if (!(ASCII_a <= c && c <= ASCII_z) && !(ASCII_A <= c && c <= ASCII_Z)) {
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) {
       *badPtr = val;
       return 0;
     }
@@ -1285,14 +1198,14 @@ doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
       *encodingName = val;
     if (encoding)
       *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
-    if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
       *badPtr = ptr;
       return 0;
     }
-    if (!name)
+    if (! name)
       return 1;
   }
-  if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
       || isGeneralTextEntity) {
     *badPtr = name;
     return 0;
@@ -1300,12 +1213,10 @@ doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
   if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
     if (standalone)
       *standalone = 1;
-  }
-  else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
+  } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
     if (standalone)
       *standalone = 0;
-  }
-  else {
+  } else {
     *badPtr = val;
     return 0;
   }
@@ -1319,11 +1230,16 @@ doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
 }
 
 static int FASTCALL
-checkCharRefNumber(int result)
-{
+checkCharRefNumber(int result) {
   switch (result >> 8) {
-  case 0xD8: case 0xD9: case 0xDA: case 0xDB:
-  case 0xDC: case 0xDD: case 0xDE: case 0xDF:
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
     return -1;
   case 0:
     if (latin1_encoding.type[result] == BT_NONXML)
@@ -1338,8 +1254,7 @@ checkCharRefNumber(int result)
 }
 
 int FASTCALL
-XmlUtf8Encode(int c, char *buf)
-{
+XmlUtf8Encode(int c, char *buf) {
   enum {
     /* minN is minimum legal resulting value for N byte sequence */
     min2 = 0x80,
@@ -1375,8 +1290,7 @@ XmlUtf8Encode(int c, char *buf)
 }
 
 int FASTCALL
-XmlUtf16Encode(int charNum, unsigned short *buf)
-{
+XmlUtf16Encode(int charNum, unsigned short *buf) {
   if (charNum < 0)
     return 0;
   if (charNum < 0x10000) {
@@ -1400,17 +1314,15 @@ struct unknown_encoding {
   char utf8[256][4];
 };
 
-#define AS_UNKNOWN_ENCODING(enc)  ((const struct unknown_encoding *) (enc))
+#define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *)(enc))
 
 int
-XmlSizeOfUnknownEncoding(void)
-{
+XmlSizeOfUnknownEncoding(void) {
   return sizeof(struct unknown_encoding);
 }
 
 static int PTRFASTCALL
-unknown_isName(const ENCODING *enc, const char *p)
-{
+unknown_isName(const ENCODING *enc, const char *p) {
   const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
   int c = uenc->convert(uenc->userData, p);
   if (c & ~0xFFFF)
@@ -1419,8 +1331,7 @@ unknown_isName(const ENCODING *enc, const char *p)
 }
 
 static int PTRFASTCALL
-unknown_isNmstrt(const ENCODING *enc, const char *p)
-{
+unknown_isNmstrt(const ENCODING *enc, const char *p) {
   const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
   int c = uenc->convert(uenc->userData, p);
   if (c & ~0xFFFF)
@@ -1429,18 +1340,15 @@ unknown_isNmstrt(const ENCODING *enc, const char *p)
 }
 
 static int PTRFASTCALL
-unknown_isInvalid(const ENCODING *enc, const char *p)
-{
+unknown_isInvalid(const ENCODING *enc, const char *p) {
   const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
   int c = uenc->convert(uenc->userData, p);
   return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
 }
 
 static enum XML_Convert_Result PTRCALL
-unknown_toUtf8(const ENCODING *enc,
-               const char **fromP, const char *fromLim,
-               char **toP, const char *toLim)
-{
+unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+               char **toP, const char *toLim) {
   const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
   char buf[XML_UTF8_ENCODE_MAX];
   for (;;) {
@@ -1458,8 +1366,7 @@ unknown_toUtf8(const ENCODING *enc,
       utf8 = buf;
       *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
                  - (BT_LEAD2 - 2));
-    }
-    else {
+    } else {
       if (n > toLim - *toP)
         return XML_CONVERT_OUTPUT_EXHAUSTED;
       (*fromP)++;
@@ -1470,20 +1377,16 @@ unknown_toUtf8(const ENCODING *enc,
 }
 
 static enum XML_Convert_Result PTRCALL
-unknown_toUtf16(const ENCODING *enc,
-                const char **fromP, const char *fromLim,
-                unsigned short **toP, const unsigned short *toLim)
-{
+unknown_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+                unsigned short **toP, const unsigned short *toLim) {
   const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
   while (*fromP < fromLim && *toP < toLim) {
     unsigned short c = uenc->utf16[(unsigned char)**fromP];
     if (c == 0) {
-      c = (unsigned short)
-          uenc->convert(uenc->userData, *fromP);
+      c = (unsigned short)uenc->convert(uenc->userData, *fromP);
       *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
                  - (BT_LEAD2 - 2));
-    }
-    else
+    } else
       (*fromP)++;
     *(*toP)++ = c;
   }
@@ -1495,19 +1398,14 @@ unknown_toUtf16(const ENCODING *enc,
 }
 
 ENCODING *
-XmlInitUnknownEncoding(void *mem,
-                       int *table,
-                       CONVERTER convert,
-                       void *userData)
-{
+XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                       void *userData) {
   int i;
   struct unknown_encoding *e = (struct unknown_encoding *)mem;
-  for (i = 0; i < (int)sizeof(struct normal_encoding); i++)
-    ((char *)mem)[i] = ((char *)&latin1_encoding)[i];
+  memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
   for (i = 0; i < 128; i++)
     if (latin1_encoding.type[i] != BT_OTHER
-        && latin1_encoding.type[i] != BT_NONXML
-        && table[i] != i)
+        && latin1_encoding.type[i] != BT_NONXML && table[i] != i)
       return 0;
   for (i = 0; i < 256; i++) {
     int c = table[i];
@@ -1517,35 +1415,30 @@ XmlInitUnknownEncoding(void *mem,
       e->utf16[i] = 0xFFFF;
       e->utf8[i][0] = 1;
       e->utf8[i][1] = 0;
-    }
-    else if (c < 0) {
+    } else if (c < 0) {
       if (c < -4)
         return 0;
       /* Multi-byte sequences need a converter function */
-      if (!convert)
+      if (! convert)
         return 0;
       e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
       e->utf8[i][0] = 0;
       e->utf16[i] = 0;
-    }
-    else if (c < 0x80) {
+    } else if (c < 0x80) {
       if (latin1_encoding.type[c] != BT_OTHER
-          && latin1_encoding.type[c] != BT_NONXML
-          && c != i)
+          && latin1_encoding.type[c] != BT_NONXML && c != i)
         return 0;
       e->normal.type[i] = latin1_encoding.type[c];
       e->utf8[i][0] = 1;
       e->utf8[i][1] = (char)c;
       e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
-    }
-    else if (checkCharRefNumber(c) < 0) {
+    } else if (checkCharRefNumber(c) < 0) {
       e->normal.type[i] = BT_NONXML;
       /* This shouldn't really get used. */
       e->utf16[i] = 0xFFFF;
       e->utf8[i][0] = 1;
       e->utf8[i][1] = 0;
-    }
-    else {
+    } else {
       if (c > 0xFFFF)
         return 0;
       if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
@@ -1590,44 +1483,32 @@ enum {
   NO_ENC
 };
 
-static const char KW_ISO_8859_1[] = {
-  ASCII_I, ASCII_S, ASCII_O, ASCII_MINUS, ASCII_8, ASCII_8, ASCII_5, ASCII_9,
-  ASCII_MINUS, ASCII_1, '\0'
-};
-static const char KW_US_ASCII[] = {
-  ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S, ASCII_C, ASCII_I, ASCII_I,
-  '\0'
-};
-static const char KW_UTF_8[] =  {
-  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'
-};
-static const char KW_UTF_16[] = {
-  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'
-};
-static const char KW_UTF_16BE[] = {
-  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_B, ASCII_E,
-  '\0'
-};
-static const char KW_UTF_16LE[] = {
-  ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_L, ASCII_E,
-  '\0'
-};
+static const char KW_ISO_8859_1[]
+    = {ASCII_I, ASCII_S, ASCII_O,     ASCII_MINUS, ASCII_8, ASCII_8,
+       ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1,     '\0'};
+static const char KW_US_ASCII[]
+    = {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S,
+       ASCII_C, ASCII_I, ASCII_I,     '\0'};
+static const char KW_UTF_8[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'};
+static const char KW_UTF_16[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'};
+static const char KW_UTF_16BE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_B, ASCII_E, '\0'};
+static const char KW_UTF_16LE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_L, ASCII_E, '\0'};
 
 static int FASTCALL
-getEncodingIndex(const char *name)
-{
-  static const char * const encodingNames[] = {
-    KW_ISO_8859_1,
-    KW_US_ASCII,
-    KW_UTF_8,
-    KW_UTF_16,
-    KW_UTF_16BE,
-    KW_UTF_16LE,
+getEncodingIndex(const char *name) {
+  static const char *const encodingNames[] = {
+      KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE,
   };
   int i;
   if (name == NULL)
     return NO_ENC;
-  for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++)
+  for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
     if (streqci(name, encodingNames[i]))
       return i;
   return UNKNOWN_ENC;
@@ -1647,15 +1528,9 @@ getEncodingIndex(const char *name)
    XML_PROLOG_STATE otherwise.
 */
 
-
 static int
-initScan(const ENCODING * const *encodingTable,
-         const INIT_ENCODING *enc,
-         int state,
-         const char *ptr,
-         const char *end,
-         const char **nextTokPtr)
-{
+initScan(const ENCODING *const *encodingTable, const INIT_ENCODING *enc,
+         int state, const char *ptr, const char *end, const char **nextTokPtr) {
   const ENCODING **encPtr;
 
   if (ptr >= end)
@@ -1680,20 +1555,17 @@ initScan(const ENCODING * const *encodingTable,
     case 0xFE:
     case 0xFF:
     case 0xEF: /* possibly first byte of UTF-8 BOM */
-      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
-          && state == XML_CONTENT_STATE)
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
         break;
       /* fall through */
     case 0x00:
     case 0x3C:
       return XML_TOK_PARTIAL;
     }
-  }
-  else {
+  } else {
     switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
     case 0xFEFF:
-      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
-          && state == XML_CONTENT_STATE)
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
         break;
       *nextTokPtr = ptr + 2;
       *encPtr = encodingTable[UTF_16BE_ENC];
@@ -1707,8 +1579,7 @@ initScan(const ENCODING * const *encodingTable,
       *encPtr = encodingTable[UTF_16LE_ENC];
       return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
     case 0xFFFE:
-      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
-          && state == XML_CONTENT_STATE)
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
         break;
       *nextTokPtr = ptr + 2;
       *encPtr = encodingTable[UTF_16LE_ENC];
@@ -1723,8 +1594,8 @@ initScan(const ENCODING * const *encodingTable,
       */
       if (state == XML_CONTENT_STATE) {
         int e = INIT_ENC_INDEX(enc);
-        if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC
-            || e == UTF_16LE_ENC || e == UTF_16_ENC)
+        if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC
+            || e == UTF_16_ENC)
           break;
       }
       if (ptr + 2 == end)
@@ -1747,8 +1618,7 @@ initScan(const ENCODING * const *encodingTable,
           break;
         *encPtr = encodingTable[UTF_16BE_ENC];
         return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
-      }
-      else if (ptr[1] == '\0') {
+      } else if (ptr[1] == '\0') {
         /* We could recover here in the case:
             - parsing an external entity
             - second byte is 0
@@ -1770,7 +1640,6 @@ initScan(const ENCODING * const *encodingTable,
   return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
 }
 
-
 #define NS(x) x
 #define ns(x) x
 #define XML_TOK_NS_C
@@ -1781,22 +1650,19 @@ initScan(const ENCODING * const *encodingTable,
 
 #ifdef XML_NS
 
-#define NS(x) x ## NS
-#define ns(x) x ## _ns
+#  define NS(x) x##NS
+#  define ns(x) x##_ns
 
-#define XML_TOK_NS_C
-#include "xmltok_ns.c"
-#undef XML_TOK_NS_C
+#  define XML_TOK_NS_C
+#  include "xmltok_ns.c"
+#  undef XML_TOK_NS_C
 
-#undef NS
-#undef ns
+#  undef NS
+#  undef ns
 
 ENCODING *
-XmlInitUnknownEncodingNS(void *mem,
-                         int *table,
-                         CONVERTER convert,
-                         void *userData)
-{
+XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                         void *userData) {
   ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
   if (enc)
     ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
diff --git a/contrib/expat/lib/xmltok.h b/contrib/expat/lib/xmltok.h
index 50926f38ab32..2adbf5307bef 100644
--- a/contrib/expat/lib/xmltok.h
+++ b/contrib/expat/lib/xmltok.h
@@ -38,16 +38,18 @@ extern "C" {
 #endif
 
 /* The following token may be returned by XmlContentTok */
-#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be
-                                    start of illegal ]]> sequence */
+#define XML_TOK_TRAILING_RSQB                                                  \
+  -5 /* ] or ]] at the end of the scan; might be                               \
+        start of illegal ]]> sequence */
 /* The following tokens may be returned by both XmlPrologTok and
    XmlContentTok.
 */
-#define XML_TOK_NONE -4          /* The string to be scanned is empty */
-#define XML_TOK_TRAILING_CR -3   /* A CR at the end of the scan;
-                                    might be part of CRLF sequence */
-#define XML_TOK_PARTIAL_CHAR -2  /* only part of a multibyte sequence */
-#define XML_TOK_PARTIAL -1       /* only part of a token */
+#define XML_TOK_NONE -4 /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR                                                    \
+  -3                            /* A CR at the end of the scan;                \
+                                   might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1      /* only part of a token */
 #define XML_TOK_INVALID 0
 
 /* The following tokens are returned by XmlContentTok; some are also
@@ -62,24 +64,24 @@ extern "C" {
 #define XML_TOK_DATA_NEWLINE 7
 #define XML_TOK_CDATA_SECT_OPEN 8
 #define XML_TOK_ENTITY_REF 9
-#define XML_TOK_CHAR_REF 10               /* numeric character reference */
+#define XML_TOK_CHAR_REF 10 /* numeric character reference */
 
 /* The following tokens may be returned by both XmlPrologTok and
    XmlContentTok.
 */
-#define XML_TOK_PI 11                     /* processing instruction */
-#define XML_TOK_XML_DECL 12               /* XML decl or text decl */
+#define XML_TOK_PI 11       /* processing instruction */
+#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
 #define XML_TOK_COMMENT 13
-#define XML_TOK_BOM 14                    /* Byte order mark */
+#define XML_TOK_BOM 14 /* Byte order mark */
 
 /* The following tokens are returned only by XmlPrologTok */
 #define XML_TOK_PROLOG_S 15
-#define XML_TOK_DECL_OPEN 16              /* <!foo */
-#define XML_TOK_DECL_CLOSE 17             /* > */
+#define XML_TOK_DECL_OPEN 16  /* <!foo */
+#define XML_TOK_DECL_CLOSE 17 /* > */
 #define XML_TOK_NAME 18
 #define XML_TOK_NMTOKEN 19
-#define XML_TOK_POUND_NAME 20             /* #name */
-#define XML_TOK_OR 21                     /* | */
+#define XML_TOK_POUND_NAME 20 /* #name */
+#define XML_TOK_OR 21         /* | */
 #define XML_TOK_PERCENT 22
 #define XML_TOK_OPEN_PAREN 23
 #define XML_TOK_CLOSE_PAREN 24
@@ -90,14 +92,14 @@ extern "C" {
 #define XML_TOK_INSTANCE_START 29
 
 /* The following occur only in element type declarations */
-#define XML_TOK_NAME_QUESTION 30          /* name? */
-#define XML_TOK_NAME_ASTERISK 31          /* name* */
-#define XML_TOK_NAME_PLUS 32              /* name+ */
-#define XML_TOK_COND_SECT_OPEN 33         /* <![ */
-#define XML_TOK_COND_SECT_CLOSE 34        /* ]]> */
-#define XML_TOK_CLOSE_PAREN_QUESTION 35   /* )? */
-#define XML_TOK_CLOSE_PAREN_ASTERISK 36   /* )* */
-#define XML_TOK_CLOSE_PAREN_PLUS 37       /* )+ */
+#define XML_TOK_NAME_QUESTION 30        /* name? */
+#define XML_TOK_NAME_ASTERISK 31        /* name* */
+#define XML_TOK_NAME_PLUS 32            /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33       /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34      /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37     /* )+ */
 #define XML_TOK_COMMA 38
 
 /* The following token is returned only by XmlAttributeValueTok */
@@ -112,20 +114,20 @@ extern "C" {
 #define XML_TOK_PREFIXED_NAME 41
 
 #ifdef XML_DTD
-#define XML_TOK_IGNORE_SECT 42
+#  define XML_TOK_IGNORE_SECT 42
 #endif /* XML_DTD */
 
 #ifdef XML_DTD
-#define XML_N_STATES 4
+#  define XML_N_STATES 4
 #else /* not XML_DTD */
-#define XML_N_STATES 3
+#  define XML_N_STATES 3
 #endif /* not XML_DTD */
 
 #define XML_PROLOG_STATE 0
 #define XML_CONTENT_STATE 1
 #define XML_CDATA_SECTION_STATE 2
 #ifdef XML_DTD
-#define XML_IGNORE_SECTION_STATE 3
+#  define XML_IGNORE_SECTION_STATE 3
 #endif /* XML_DTD */
 
 #define XML_N_LITERAL_TYPES 2
@@ -153,52 +155,41 @@ typedef struct {
 struct encoding;
 typedef struct encoding ENCODING;
 
-typedef int (PTRCALL *SCANNER)(const ENCODING *,
-                               const char *,
-                               const char *,
-                               const char **);
+typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
+                              const char **);
 
 enum XML_Convert_Result {
   XML_CONVERT_COMPLETED = 0,
   XML_CONVERT_INPUT_INCOMPLETE = 1,
-  XML_CONVERT_OUTPUT_EXHAUSTED = 2  /* and therefore potentially input remaining as well */
+  XML_CONVERT_OUTPUT_EXHAUSTED
+  = 2 /* and therefore potentially input remaining as well */
 };
 
 struct encoding {
   SCANNER scanners[XML_N_STATES];
   SCANNER literalScanners[XML_N_LITERAL_TYPES];
-  int (PTRCALL *nameMatchesAscii)(const ENCODING *,
-                                  const char *,
-                                  const char *,
-                                  const char *);
-  int (PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
+                                 const char *);
+  int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
   const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
-  int (PTRCALL *getAtts)(const ENCODING *enc,
-                         const char *ptr,
-                         int attsMax,
-                         ATTRIBUTE *atts);
-  int (PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
-  int (PTRCALL *predefinedEntityName)(const ENCODING *,
-                                      const char *,
-                                      const char *);
-  void (PTRCALL *updatePosition)(const ENCODING *,
-                                 const char *ptr,
-                                 const char *end,
-                                 POSITION *);
-  int (PTRCALL *isPublicId)(const ENCODING *enc,
-                            const char *ptr,
-                            const char *end,
-                            const char **badPtr);
-  enum XML_Convert_Result (PTRCALL *utf8Convert)(const ENCODING *enc,
-                              const char **fromP,
-                              const char *fromLim,
-                              char **toP,
-                              const char *toLim);
-  enum XML_Convert_Result (PTRCALL *utf16Convert)(const ENCODING *enc,
-                               const char **fromP,
-                               const char *fromLim,
-                               unsigned short **toP,
-                               const unsigned short *toLim);
+  int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                        ATTRIBUTE *atts);
+  int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
+                                     const char *);
+  void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
+                                const char *end, POSITION *);
+  int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
+                           const char *end, const char **badPtr);
+  enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
+                                                const char **fromP,
+                                                const char *fromLim, char **toP,
+                                                const char *toLim);
+  enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
+                                                 const char **fromP,
+                                                 const char *fromLim,
+                                                 unsigned short **toP,
+                                                 const unsigned short *toLim);
   int minBytesPerChar;
   char isUtf8;
   char isUtf16;
@@ -225,66 +216,62 @@ struct encoding {
    the prolog outside literals, comments and processing instructions.
 */
 
-
-#define XmlTok(enc, state, ptr, end, nextTokPtr) \
+#define XmlTok(enc, state, ptr, end, nextTokPtr)                               \
   (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
 
-#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
-   XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+#define XmlPrologTok(enc, ptr, end, nextTokPtr)                                \
+  XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
 
-#define XmlContentTok(enc, ptr, end, nextTokPtr) \
-   XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+#define XmlContentTok(enc, ptr, end, nextTokPtr)                               \
+  XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
 
-#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
-   XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr)                          \
+  XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
 
 #ifdef XML_DTD
 
-#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
-   XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+#  define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr)                       \
+    XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
 
 #endif /* XML_DTD */
 
 /* This is used for performing a 2nd-level tokenization on the content
    of a literal that has already been returned by XmlTok.
 */
-#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr)                  \
   (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
 
-#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
-   XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr)                        \
+  XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
 
-#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
-   XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr)                           \
+  XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
 
-#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)                             \
   (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
 
-#define XmlNameLength(enc, ptr) \
-  (((enc)->nameLength)(enc, ptr))
+#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
 
-#define XmlSkipS(enc, ptr) \
-  (((enc)->skipS)(enc, ptr))
+#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
 
-#define XmlGetAttributes(enc, ptr, attsMax, atts) \
+#define XmlGetAttributes(enc, ptr, attsMax, atts)                              \
   (((enc)->getAtts)(enc, ptr, attsMax, atts))
 
-#define XmlCharRefNumber(enc, ptr) \
-  (((enc)->charRefNumber)(enc, ptr))
+#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
 
-#define XmlPredefinedEntityName(enc, ptr, end) \
+#define XmlPredefinedEntityName(enc, ptr, end)                                 \
   (((enc)->predefinedEntityName)(enc, ptr, end))
 
-#define XmlUpdatePosition(enc, ptr, end, pos) \
+#define XmlUpdatePosition(enc, ptr, end, pos)                                  \
   (((enc)->updatePosition)(enc, ptr, end, pos))
 
-#define XmlIsPublicId(enc, ptr, end, badPtr) \
+#define XmlIsPublicId(enc, ptr, end, badPtr)                                   \
   (((enc)->isPublicId)(enc, ptr, end, badPtr))
 
-#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim)                        \
   (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
 
-#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim)                       \
   (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
 
 typedef struct {
@@ -292,16 +279,11 @@ typedef struct {
   const ENCODING **encPtr;
 } INIT_ENCODING;
 
-int XmlParseXmlDecl(int isGeneralTextEntity,
-                    const ENCODING *enc,
-                    const char *ptr,
-                    const char *end,
-                    const char **badPtr,
-                    const char **versionPtr,
-                    const char **versionEndPtr,
+int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
                     const char **encodingNamePtr,
-                    const ENCODING **namedEncodingPtr,
-                    int *standalonePtr);
+                    const ENCODING **namedEncodingPtr, int *standalonePtr);
 
 int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
 const ENCODING *XmlGetUtf8InternalEncoding(void);
@@ -310,34 +292,22 @@ int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
 int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
 int XmlSizeOfUnknownEncoding(void);
 
+typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);
 
-typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);
-
-ENCODING *
-XmlInitUnknownEncoding(void *mem,
-                       int *table,
-                       CONVERTER convert,
-                       void *userData);
+ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                                 void *userData);
 
-int XmlParseXmlDeclNS(int isGeneralTextEntity,
-                      const ENCODING *enc,
-                      const char *ptr,
-                      const char *end,
-                      const char **badPtr,
-                      const char **versionPtr,
-                      const char **versionEndPtr,
+int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
+                      const char *ptr, const char *end, const char **badPtr,
+                      const char **versionPtr, const char **versionEndPtr,
                       const char **encodingNamePtr,
-                      const ENCODING **namedEncodingPtr,
-                      int *standalonePtr);
+                      const ENCODING **namedEncodingPtr, int *standalonePtr);
 
 int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
 const ENCODING *XmlGetUtf8InternalEncodingNS(void);
 const ENCODING *XmlGetUtf16InternalEncodingNS(void);
-ENCODING *
-XmlInitUnknownEncodingNS(void *mem,
-                         int *table,
-                         CONVERTER convert,
-                         void *userData);
+ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                                   void *userData);
 #ifdef __cplusplus
 }
 #endif
diff --git a/contrib/expat/lib/xmltok_impl.c b/contrib/expat/lib/xmltok_impl.c
index 4d9ae7dc3896..c209221cd79d 100644
--- a/contrib/expat/lib/xmltok_impl.c
+++ b/contrib/expat/lib/xmltok_impl.c
@@ -32,130 +32,124 @@
 
 #ifdef XML_TOK_IMPL_C
 
-#ifndef IS_INVALID_CHAR
-#define IS_INVALID_CHAR(enc, ptr, n) (0)
-#endif
-
-#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
-    case BT_LEAD ## n: \
-      if (end - ptr < n) \
-        return XML_TOK_PARTIAL_CHAR; \
-      if (IS_INVALID_CHAR(enc, ptr, n)) { \
-        *(nextTokPtr) = (ptr); \
-        return XML_TOK_INVALID; \
-      } \
-      ptr += n; \
-      break;
+#  ifndef IS_INVALID_CHAR
+#    define IS_INVALID_CHAR(enc, ptr, n) (0)
+#  endif
+
+#  define INVALID_LEAD_CASE(n, ptr, nextTokPtr)                                \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n)) {                                        \
+      *(nextTokPtr) = (ptr);                                                   \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
 
-#define INVALID_CASES(ptr, nextTokPtr) \
-  INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
-  INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
-  INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
-  case BT_NONXML: \
-  case BT_MALFORM: \
-  case BT_TRAIL: \
-    *(nextTokPtr) = (ptr); \
+#  define INVALID_CASES(ptr, nextTokPtr)                                       \
+    INVALID_LEAD_CASE(2, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(3, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(4, ptr, nextTokPtr)                                      \
+  case BT_NONXML:                                                              \
+  case BT_MALFORM:                                                             \
+  case BT_TRAIL:                                                               \
+    *(nextTokPtr) = (ptr);                                                     \
     return XML_TOK_INVALID;
 
-#define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
-   case BT_LEAD ## n: \
-     if (end - ptr < n) \
-       return XML_TOK_PARTIAL_CHAR; \
-     if (!IS_NAME_CHAR(enc, ptr, n)) { \
-       *nextTokPtr = ptr; \
-       return XML_TOK_INVALID; \
-     } \
-     ptr += n; \
-     break;
-
-#define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
-  case BT_NONASCII: \
-    if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
-      *nextTokPtr = ptr; \
-      return XML_TOK_INVALID; \
-    } \
-    /* fall through */ \
-  case BT_NMSTRT: \
-  case BT_HEX: \
-  case BT_DIGIT: \
-  case BT_NAME: \
-  case BT_MINUS: \
-    ptr += MINBPC(enc); \
-    break; \
-  CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
-  CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
-  CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
-
-#define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
-   case BT_LEAD ## n: \
-     if (end - ptr < n) \
-       return XML_TOK_PARTIAL_CHAR; \
-     if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
-       *nextTokPtr = ptr; \
-       return XML_TOK_INVALID; \
-     } \
-     ptr += n; \
-     break;
-
-#define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
-  case BT_NONASCII: \
-    if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
-      *nextTokPtr = ptr; \
-      return XML_TOK_INVALID; \
-    } \
-    /* fall through */ \
-  case BT_NMSTRT: \
-  case BT_HEX: \
-    ptr += MINBPC(enc); \
-    break; \
-  CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
-  CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
-  CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
-
-#ifndef PREFIX
-#define PREFIX(ident) ident
-#endif
-
-
-#define HAS_CHARS(enc, ptr, end, count) \
-    (end - ptr >= count * MINBPC(enc))
+#  define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr)                        \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (! IS_NAME_CHAR(enc, ptr, n)) {                                         \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
 
-#define HAS_CHAR(enc, ptr, end) \
-    HAS_CHARS(enc, ptr, end, 1)
+#  define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)                          \
+  case BT_NONASCII:                                                            \
+    if (! IS_NAME_CHAR_MINBPC(enc, ptr)) {                                     \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+  case BT_DIGIT:                                                               \
+  case BT_NAME:                                                                \
+  case BT_MINUS:                                                               \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr)                      \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (! IS_NMSTRT_CHAR(enc, ptr, n)) {                                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
 
-#define REQUIRE_CHARS(enc, ptr, end, count) \
-    { \
-      if (! HAS_CHARS(enc, ptr, end, count)) { \
-        return XML_TOK_PARTIAL; \
-      } \
+#  define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)                        \
+  case BT_NONASCII:                                                            \
+    if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {                                   \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  ifndef PREFIX
+#    define PREFIX(ident) ident
+#  endif
+
+#  define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
+
+#  define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
+
+#  define REQUIRE_CHARS(enc, ptr, end, count)                                  \
+    {                                                                          \
+      if (! HAS_CHARS(enc, ptr, end, count)) {                                 \
+        return XML_TOK_PARTIAL;                                                \
+      }                                                                        \
     }
 
-#define REQUIRE_CHAR(enc, ptr, end) \
-    REQUIRE_CHARS(enc, ptr, end, 1)
-
+#  define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
 
 /* ptr points to character following "<!-" */
 
 static int PTRCALL
-PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
-                    const char *end, const char **nextTokPtr)
-{
+PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
   if (HAS_CHAR(enc, ptr, end)) {
-    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+    if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
     ptr += MINBPC(enc);
     while (HAS_CHAR(enc, ptr, end)) {
       switch (BYTE_TYPE(enc, ptr)) {
-      INVALID_CASES(ptr, nextTokPtr)
+        INVALID_CASES(ptr, nextTokPtr)
       case BT_MINUS:
         ptr += MINBPC(enc);
         REQUIRE_CHAR(enc, ptr, end);
         if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
           ptr += MINBPC(enc);
           REQUIRE_CHAR(enc, ptr, end);
-          if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
             *nextTokPtr = ptr;
             return XML_TOK_INVALID;
           }
@@ -175,9 +169,8 @@ PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
 /* ptr points to character following "<!" */
 
 static int PTRCALL
-PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
-                 const char *end, const char **nextTokPtr)
-{
+PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
+                 const char **nextTokPtr) {
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_MINUS:
@@ -199,12 +192,17 @@ PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
       REQUIRE_CHARS(enc, ptr, end, 2);
       /* don't allow <!ENTITY% foo "whatever"> */
       switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
-      case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_PERCNT:
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       /* fall through */
-    case BT_S: case BT_CR: case BT_LF:
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
       *nextTokPtr = ptr;
       return XML_TOK_DECL_OPEN;
     case BT_NMSTRT:
@@ -220,12 +218,12 @@ PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
 }
 
 static int PTRCALL
-PREFIX(checkPiTarget)(const ENCODING *UNUSED_P(enc), const char *ptr,
-                      const char *end, int *tokPtr)
-{
+PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
+                      int *tokPtr) {
   int upper = 0;
+  UNUSED_P(enc);
   *tokPtr = XML_TOK_PI;
-  if (end - ptr != MINBPC(enc)*3)
+  if (end - ptr != MINBPC(enc) * 3)
     return 1;
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case ASCII_x:
@@ -265,30 +263,31 @@ PREFIX(checkPiTarget)(const ENCODING *UNUSED_P(enc), const char *ptr,
 /* ptr points to character following "<?" */
 
 static int PTRCALL
-PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
-               const char *end, const char **nextTokPtr)
-{
+PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
+               const char **nextTokPtr) {
   int tok;
   const char *target = ptr;
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-    case BT_S: case BT_CR: case BT_LF:
-      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       ptr += MINBPC(enc);
       while (HAS_CHAR(enc, ptr, end)) {
         switch (BYTE_TYPE(enc, ptr)) {
-        INVALID_CASES(ptr, nextTokPtr)
+          INVALID_CASES(ptr, nextTokPtr)
         case BT_QUEST:
           ptr += MINBPC(enc);
           REQUIRE_CHAR(enc, ptr, end);
@@ -304,7 +303,7 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
       }
       return XML_TOK_PARTIAL;
     case BT_QUEST:
-      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
@@ -324,16 +323,16 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
 }
 
 static int PTRCALL
-PREFIX(scanCdataSection)(const ENCODING *UNUSED_P(enc), const char *ptr,
-                         const char *end, const char **nextTokPtr)
-{
-  static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
-                                     ASCII_T, ASCII_A, ASCII_LSQB };
+PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
+  static const char CDATA_LSQB[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
   int i;
+  UNUSED_P(enc);
   /* CDATA[ */
   REQUIRE_CHARS(enc, ptr, end, 6);
   for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
-    if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
+    if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
@@ -343,9 +342,8 @@ PREFIX(scanCdataSection)(const ENCODING *UNUSED_P(enc), const char *ptr,
 }
 
 static int PTRCALL
-PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
-                        const char *end, const char **nextTokPtr)
-{
+PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                        const char **nextTokPtr) {
   if (ptr >= end)
     return XML_TOK_NONE;
   if (MINBPC(enc) > 1) {
@@ -361,11 +359,11 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
   case BT_RSQB:
     ptr += MINBPC(enc);
     REQUIRE_CHAR(enc, ptr, end);
-    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
       break;
     ptr += MINBPC(enc);
     REQUIRE_CHAR(enc, ptr, end);
-    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
       ptr -= MINBPC(enc);
       break;
     }
@@ -381,23 +379,25 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
   case BT_LF:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
-  INVALID_CASES(ptr, nextTokPtr)
+    INVALID_CASES(ptr, nextTokPtr)
   default:
     ptr += MINBPC(enc);
     break;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: \
-      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
-        *nextTokPtr = ptr; \
-        return XML_TOK_DATA_CHARS; \
-      } \
-      ptr += n; \
-      break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_NONXML:
     case BT_MALFORM:
     case BT_TRAIL:
@@ -418,23 +418,26 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
 /* ptr points to character following "</" */
 
 static int PTRCALL
-PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
-                   const char *end, const char **nextTokPtr)
-{
+PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-    case BT_S: case BT_CR: case BT_LF:
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
       for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
         switch (BYTE_TYPE(enc, ptr)) {
-        case BT_S: case BT_CR: case BT_LF:
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
           break;
         case BT_GT:
           *nextTokPtr = ptr + MINBPC(enc);
@@ -445,13 +448,13 @@ PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
         }
       }
       return XML_TOK_PARTIAL;
-#ifdef XML_NS
+#  ifdef XML_NS
     case BT_COLON:
       /* no need to check qname syntax here,
          since end-tag must match exactly */
       ptr += MINBPC(enc);
       break;
-#endif
+#  endif
     case BT_GT:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_END_TAG;
@@ -466,9 +469,8 @@ PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
 /* ptr points to character following "&#X" */
 
 static int PTRCALL
-PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
-                       const char *end, const char **nextTokPtr)
-{
+PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
   if (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
@@ -498,9 +500,8 @@ PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
 /* ptr points to character following "&#" */
 
 static int PTRCALL
-PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
-                    const char *end, const char **nextTokPtr)
-{
+PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
   if (HAS_CHAR(enc, ptr, end)) {
     if (CHAR_MATCHES(enc, ptr, ASCII_x))
       return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
@@ -531,11 +532,10 @@ PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
 
 static int PTRCALL
 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
-                const char **nextTokPtr)
-{
+                const char **nextTokPtr) {
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_NUM:
     return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
@@ -544,7 +544,7 @@ PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_ENTITY_REF;
@@ -560,15 +560,14 @@ PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
 
 static int PTRCALL
 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
-                 const char **nextTokPtr)
-{
-#ifdef XML_NS
+                 const char **nextTokPtr) {
+#  ifdef XML_NS
   int hadColon = 0;
-#endif
+#  endif
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-#ifdef XML_NS
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
     case BT_COLON:
       if (hadColon) {
         *nextTokPtr = ptr;
@@ -578,14 +577,16 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
       switch (BYTE_TYPE(enc, ptr)) {
-      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
       default:
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       break;
-#endif
-    case BT_S: case BT_CR: case BT_LF:
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
       for (;;) {
         int t;
 
@@ -605,101 +606,101 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
         }
       }
       /* fall through */
-    case BT_EQUALS:
-      {
-        int open;
-#ifdef XML_NS
-        hadColon = 0;
-#endif
-        for (;;) {
-          ptr += MINBPC(enc);
-          REQUIRE_CHAR(enc, ptr, end);
-          open = BYTE_TYPE(enc, ptr);
-          if (open == BT_QUOT || open == BT_APOS)
-            break;
-          switch (open) {
-          case BT_S:
-          case BT_LF:
-          case BT_CR:
-            break;
-          default:
-            *nextTokPtr = ptr;
-            return XML_TOK_INVALID;
-          }
-        }
+    case BT_EQUALS: {
+      int open;
+#  ifdef XML_NS
+      hadColon = 0;
+#  endif
+      for (;;) {
         ptr += MINBPC(enc);
-        /* in attribute value */
-        for (;;) {
-          int t;
-          REQUIRE_CHAR(enc, ptr, end);
-          t = BYTE_TYPE(enc, ptr);
-          if (t == open)
-            break;
-          switch (t) {
+        REQUIRE_CHAR(enc, ptr, end);
+        open = BYTE_TYPE(enc, ptr);
+        if (open == BT_QUOT || open == BT_APOS)
+          break;
+        switch (open) {
+        case BT_S:
+        case BT_LF:
+        case BT_CR:
+          break;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      ptr += MINBPC(enc);
+      /* in attribute value */
+      for (;;) {
+        int t;
+        REQUIRE_CHAR(enc, ptr, end);
+        t = BYTE_TYPE(enc, ptr);
+        if (t == open)
+          break;
+        switch (t) {
           INVALID_CASES(ptr, nextTokPtr)
-          case BT_AMP:
-            {
-              int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
-              if (tok <= 0) {
-                if (tok == XML_TOK_INVALID)
-                  *nextTokPtr = ptr;
-                return tok;
-              }
-              break;
-            }
-          case BT_LT:
-            *nextTokPtr = ptr;
-            return XML_TOK_INVALID;
-          default:
-            ptr += MINBPC(enc);
-            break;
+        case BT_AMP: {
+          int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
+          if (tok <= 0) {
+            if (tok == XML_TOK_INVALID)
+              *nextTokPtr = ptr;
+            return tok;
           }
+          break;
+        }
+        case BT_LT:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        default:
+          ptr += MINBPC(enc);
+          break;
         }
+      }
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+        break;
+      case BT_SOL:
+        goto sol;
+      case BT_GT:
+        goto gt;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      /* ptr points to closing quote */
+      for (;;) {
         ptr += MINBPC(enc);
         REQUIRE_CHAR(enc, ptr, end);
         switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
         case BT_S:
         case BT_CR:
         case BT_LF:
-          break;
-        case BT_SOL:
-          goto sol;
+          continue;
         case BT_GT:
-          goto gt;
-        default:
-          *nextTokPtr = ptr;
-          return XML_TOK_INVALID;
-        }
-        /* ptr points to closing quote */
-        for (;;) {
+        gt:
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_START_TAG_WITH_ATTS;
+        case BT_SOL:
+        sol:
           ptr += MINBPC(enc);
           REQUIRE_CHAR(enc, ptr, end);
-          switch (BYTE_TYPE(enc, ptr)) {
-          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
-          case BT_S: case BT_CR: case BT_LF:
-            continue;
-          case BT_GT:
-          gt:
-            *nextTokPtr = ptr + MINBPC(enc);
-            return XML_TOK_START_TAG_WITH_ATTS;
-          case BT_SOL:
-          sol:
-            ptr += MINBPC(enc);
-            REQUIRE_CHAR(enc, ptr, end);
-            if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
-              *nextTokPtr = ptr;
-              return XML_TOK_INVALID;
-            }
-            *nextTokPtr = ptr + MINBPC(enc);
-            return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
-          default:
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
             *nextTokPtr = ptr;
             return XML_TOK_INVALID;
           }
-          break;
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
         }
         break;
       }
+      break;
+    }
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
@@ -712,14 +713,13 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 
 static int PTRCALL
 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
-               const char **nextTokPtr)
-{
-#ifdef XML_NS
+               const char **nextTokPtr) {
+#  ifdef XML_NS
   int hadColon;
-#endif
+#  endif
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_EXCL:
     ptr += MINBPC(enc);
     REQUIRE_CHAR(enc, ptr, end);
@@ -727,8 +727,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_MINUS:
       return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     case BT_LSQB:
-      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
-                                      end, nextTokPtr);
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -740,14 +739,14 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
-#ifdef XML_NS
+#  ifdef XML_NS
   hadColon = 0;
-#endif
+#  endif
   /* we have a start-tag */
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-#ifdef XML_NS
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
     case BT_COLON:
       if (hadColon) {
         *nextTokPtr = ptr;
@@ -757,34 +756,37 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
       switch (BYTE_TYPE(enc, ptr)) {
-      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
       default:
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       break;
-#endif
-    case BT_S: case BT_CR: case BT_LF:
-      {
-        ptr += MINBPC(enc);
-        while (HAS_CHAR(enc, ptr, end)) {
-          switch (BYTE_TYPE(enc, ptr)) {
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF: {
+      ptr += MINBPC(enc);
+      while (HAS_CHAR(enc, ptr, end)) {
+        switch (BYTE_TYPE(enc, ptr)) {
           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
-          case BT_GT:
-            goto gt;
-          case BT_SOL:
-            goto sol;
-          case BT_S: case BT_CR: case BT_LF:
-            ptr += MINBPC(enc);
-            continue;
-          default:
-            *nextTokPtr = ptr;
-            return XML_TOK_INVALID;
-          }
-          return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
+        case BT_GT:
+          goto gt;
+        case BT_SOL:
+          goto sol;
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          ptr += MINBPC(enc);
+          continue;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
         }
-        return XML_TOK_PARTIAL;
+        return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
       }
+      return XML_TOK_PARTIAL;
+    }
     case BT_GT:
     gt:
       *nextTokPtr = ptr + MINBPC(enc);
@@ -793,7 +795,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
     sol:
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
-      if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
@@ -809,8 +811,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 
 static int PTRCALL
 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
-                   const char **nextTokPtr)
-{
+                   const char **nextTokPtr) {
   if (ptr >= end)
     return XML_TOK_NONE;
   if (MINBPC(enc) > 1) {
@@ -842,48 +843,50 @@ PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
     ptr += MINBPC(enc);
     if (! HAS_CHAR(enc, ptr, end))
       return XML_TOK_TRAILING_RSQB;
-    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
       break;
     ptr += MINBPC(enc);
     if (! HAS_CHAR(enc, ptr, end))
       return XML_TOK_TRAILING_RSQB;
-    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
       ptr -= MINBPC(enc);
       break;
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
-  INVALID_CASES(ptr, nextTokPtr)
+    INVALID_CASES(ptr, nextTokPtr)
   default:
     ptr += MINBPC(enc);
     break;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: \
-      if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
-        *nextTokPtr = ptr; \
-        return XML_TOK_DATA_CHARS; \
-      } \
-      ptr += n; \
-      break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_RSQB:
       if (HAS_CHARS(enc, ptr, end, 2)) {
-         if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
-           ptr += MINBPC(enc);
-           break;
-         }
-         if (HAS_CHARS(enc, ptr, end, 3)) {
-           if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
-             ptr += MINBPC(enc);
-             break;
-           }
-           *nextTokPtr = ptr + 2*MINBPC(enc);
-           return XML_TOK_INVALID;
-         }
+        if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
+          ptr += MINBPC(enc);
+          break;
+        }
+        if (HAS_CHARS(enc, ptr, end, 3)) {
+          if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
+            ptr += MINBPC(enc);
+            break;
+          }
+          *nextTokPtr = ptr + 2 * MINBPC(enc);
+          return XML_TOK_INVALID;
+        }
       }
       /* fall through */
     case BT_AMP:
@@ -908,12 +911,14 @@ PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
 
 static int PTRCALL
 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
-                    const char **nextTokPtr)
-{
+                    const char **nextTokPtr) {
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
-  case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_S:
+  case BT_LF:
+  case BT_CR:
+  case BT_PERCNT:
     *nextTokPtr = ptr;
     return XML_TOK_PERCENT;
   default:
@@ -922,7 +927,7 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_PARAM_ENTITY_REF;
@@ -936,20 +941,24 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
 
 static int PTRCALL
 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
-                      const char **nextTokPtr)
-{
+                      const char **nextTokPtr) {
   REQUIRE_CHAR(enc, ptr, end);
   switch (BYTE_TYPE(enc, ptr)) {
-  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-    case BT_CR: case BT_LF: case BT_S:
-    case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_RPAR:
+    case BT_GT:
+    case BT_PERCNT:
+    case BT_VERBAR:
       *nextTokPtr = ptr;
       return XML_TOK_POUND_NAME;
     default:
@@ -961,14 +970,12 @@ PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
 }
 
 static int PTRCALL
-PREFIX(scanLit)(int open, const ENCODING *enc,
-                const char *ptr, const char *end,
-                const char **nextTokPtr)
-{
+PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
+                const char **nextTokPtr) {
   while (HAS_CHAR(enc, ptr, end)) {
     int t = BYTE_TYPE(enc, ptr);
     switch (t) {
-    INVALID_CASES(ptr, nextTokPtr)
+      INVALID_CASES(ptr, nextTokPtr)
     case BT_QUOT:
     case BT_APOS:
       ptr += MINBPC(enc);
@@ -978,8 +985,12 @@ PREFIX(scanLit)(int open, const ENCODING *enc,
         return -XML_TOK_LITERAL;
       *nextTokPtr = ptr;
       switch (BYTE_TYPE(enc, ptr)) {
-      case BT_S: case BT_CR: case BT_LF:
-      case BT_GT: case BT_PERCNT: case BT_LSQB:
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_GT:
+      case BT_PERCNT:
+      case BT_LSQB:
         return XML_TOK_LITERAL;
       default:
         return XML_TOK_INVALID;
@@ -994,8 +1005,7 @@ PREFIX(scanLit)(int open, const ENCODING *enc,
 
 static int PTRCALL
 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
-                  const char **nextTokPtr)
-{
+                  const char **nextTokPtr) {
   int tok;
   if (ptr >= end)
     return XML_TOK_NONE;
@@ -1013,27 +1023,26 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_APOS:
     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
-  case BT_LT:
-    {
-      ptr += MINBPC(enc);
-      REQUIRE_CHAR(enc, ptr, end);
-      switch (BYTE_TYPE(enc, ptr)) {
-      case BT_EXCL:
-        return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
-      case BT_QUEST:
-        return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
-      case BT_NMSTRT:
-      case BT_HEX:
-      case BT_NONASCII:
-      case BT_LEAD2:
-      case BT_LEAD3:
-      case BT_LEAD4:
-        *nextTokPtr = ptr - MINBPC(enc);
-        return XML_TOK_INSTANCE_START;
-      }
-      *nextTokPtr = ptr;
-      return XML_TOK_INVALID;
+  case BT_LT: {
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_EXCL:
+      return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_QUEST:
+      return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_NMSTRT:
+    case BT_HEX:
+    case BT_NONASCII:
+    case BT_LEAD2:
+    case BT_LEAD3:
+    case BT_LEAD4:
+      *nextTokPtr = ptr - MINBPC(enc);
+      return XML_TOK_INSTANCE_START;
     }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
   case BT_CR:
     if (ptr + MINBPC(enc) == end) {
       *nextTokPtr = end;
@@ -1041,13 +1050,15 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
       return -XML_TOK_PROLOG_S;
     }
     /* fall through */
-  case BT_S: case BT_LF:
+  case BT_S:
+  case BT_LF:
     for (;;) {
       ptr += MINBPC(enc);
       if (! HAS_CHAR(enc, ptr, end))
         break;
       switch (BYTE_TYPE(enc, ptr)) {
-      case BT_S: case BT_LF:
+      case BT_S:
+      case BT_LF:
         break;
       case BT_CR:
         /* don't split CR/LF pair */
@@ -1076,7 +1087,7 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
       REQUIRE_CHARS(enc, ptr, end, 2);
       if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
-        *nextTokPtr = ptr + 2*MINBPC(enc);
+        *nextTokPtr = ptr + 2 * MINBPC(enc);
         return XML_TOK_COND_SECT_CLOSE;
       }
     }
@@ -1099,8 +1110,12 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_PLUS:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_PLUS;
-    case BT_CR: case BT_LF: case BT_S:
-    case BT_GT: case BT_COMMA: case BT_VERBAR:
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_GT:
+    case BT_COMMA:
+    case BT_VERBAR:
     case BT_RPAR:
       *nextTokPtr = ptr;
       return XML_TOK_CLOSE_PAREN;
@@ -1115,24 +1130,26 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     return XML_TOK_DECL_CLOSE;
   case BT_NUM:
     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
-#define LEAD_CASE(n) \
-  case BT_LEAD ## n: \
-    if (end - ptr < n) \
-      return XML_TOK_PARTIAL_CHAR; \
-    if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
-      ptr += n; \
-      tok = XML_TOK_NAME; \
-      break; \
-    } \
-    if (IS_NAME_CHAR(enc, ptr, n)) { \
-      ptr += n; \
-      tok = XML_TOK_NMTOKEN; \
-      break; \
-    } \
-    *nextTokPtr = ptr; \
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_NMSTRT_CHAR(enc, ptr, n)) {                                         \
+      ptr += n;                                                                \
+      tok = XML_TOK_NAME;                                                      \
+      break;                                                                   \
+    }                                                                          \
+    if (IS_NAME_CHAR(enc, ptr, n)) {                                           \
+      ptr += n;                                                                \
+      tok = XML_TOK_NMTOKEN;                                                   \
+      break;                                                                   \
+    }                                                                          \
+    *nextTokPtr = ptr;                                                         \
     return XML_TOK_INVALID;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+    LEAD_CASE(2)
+    LEAD_CASE(3)
+    LEAD_CASE(4)
+#  undef LEAD_CASE
   case BT_NMSTRT:
   case BT_HEX:
     tok = XML_TOK_NAME;
@@ -1141,9 +1158,9 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_DIGIT:
   case BT_NAME:
   case BT_MINUS:
-#ifdef XML_NS
+#  ifdef XML_NS
   case BT_COLON:
-#endif
+#  endif
     tok = XML_TOK_NMTOKEN;
     ptr += MINBPC(enc);
     break;
@@ -1165,13 +1182,19 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
-    case BT_GT: case BT_RPAR: case BT_COMMA:
-    case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
-    case BT_S: case BT_CR: case BT_LF:
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_GT:
+    case BT_RPAR:
+    case BT_COMMA:
+    case BT_VERBAR:
+    case BT_LSQB:
+    case BT_PERCNT:
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
       *nextTokPtr = ptr;
       return tok;
-#ifdef XML_NS
+#  ifdef XML_NS
     case BT_COLON:
       ptr += MINBPC(enc);
       switch (tok) {
@@ -1179,7 +1202,7 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
         REQUIRE_CHAR(enc, ptr, end);
         tok = XML_TOK_PREFIXED_NAME;
         switch (BYTE_TYPE(enc, ptr)) {
-        CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+          CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
         default:
           tok = XML_TOK_NMTOKEN;
           break;
@@ -1190,23 +1213,23 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
         break;
       }
       break;
-#endif
+#  endif
     case BT_PLUS:
-      if (tok == XML_TOK_NMTOKEN)  {
+      if (tok == XML_TOK_NMTOKEN) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_PLUS;
     case BT_AST:
-      if (tok == XML_TOK_NMTOKEN)  {
+      if (tok == XML_TOK_NMTOKEN) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_ASTERISK;
     case BT_QUEST:
-      if (tok == XML_TOK_NMTOKEN)  {
+      if (tok == XML_TOK_NMTOKEN) {
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
@@ -1221,9 +1244,8 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
 }
 
 static int PTRCALL
-PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
-                          const char *end, const char **nextTokPtr)
-{
+PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                          const char **nextTokPtr) {
   const char *start;
   if (ptr >= end)
     return XML_TOK_NONE;
@@ -1238,10 +1260,14 @@ PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
   start = ptr;
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: ptr += n; break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
@@ -1287,9 +1313,8 @@ PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
 }
 
 static int PTRCALL
-PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
-                       const char *end, const char **nextTokPtr)
-{
+PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
   const char *start;
   if (ptr >= end)
     return XML_TOK_NONE;
@@ -1304,10 +1329,14 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
   start = ptr;
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: ptr += n; break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
@@ -1315,8 +1344,7 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
       return XML_TOK_DATA_CHARS;
     case BT_PERCNT:
       if (ptr == start) {
-        int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
-                                       end, nextTokPtr);
+        int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
         return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
       }
       *nextTokPtr = ptr;
@@ -1349,12 +1377,11 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
   return XML_TOK_DATA_CHARS;
 }
 
-#ifdef XML_DTD
+#  ifdef XML_DTD
 
 static int PTRCALL
-PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
-                         const char *end, const char **nextTokPtr)
-{
+PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
   int level = 0;
   if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
@@ -1365,7 +1392,7 @@ PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-    INVALID_CASES(ptr, nextTokPtr)
+      INVALID_CASES(ptr, nextTokPtr)
     case BT_LT:
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
@@ -1402,12 +1429,11 @@ PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
   return XML_TOK_PARTIAL;
 }
 
-#endif /* XML_DTD */
+#  endif /* XML_DTD */
 
 static int PTRCALL
 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
-                   const char **badPtr)
-{
+                   const char **badPtr) {
   ptr += MINBPC(enc);
   end -= MINBPC(enc);
   for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
@@ -1430,9 +1456,9 @@ PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
     case BT_AST:
     case BT_PERCNT:
     case BT_NUM:
-#ifdef XML_NS
+#  ifdef XML_NS
     case BT_COLON:
-#endif
+#  endif
       break;
     case BT_S:
       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
@@ -1442,7 +1468,7 @@ PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
       break;
     case BT_NAME:
     case BT_NMSTRT:
-      if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
+      if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
         break;
       /* fall through */
     default:
@@ -1466,9 +1492,8 @@ PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
 */
 
 static int PTRCALL
-PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
-                int attsMax, ATTRIBUTE *atts)
-{
+PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                ATTRIBUTE *atts) {
   enum { other, inName, inValue } state = inName;
   int nAtts = 0;
   int open = 0; /* defined when state == inValue;
@@ -1476,32 +1501,35 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 
   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define START_NAME \
-      if (state == other) { \
-        if (nAtts < attsMax) { \
-          atts[nAtts].name = ptr; \
-          atts[nAtts].normalized = 1; \
-        } \
-        state = inName; \
-      }
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define START_NAME                                                           \
+    if (state == other) {                                                      \
+      if (nAtts < attsMax) {                                                   \
+        atts[nAtts].name = ptr;                                                \
+        atts[nAtts].normalized = 1;                                            \
+      }                                                                        \
+      state = inName;                                                          \
+    }
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    START_NAME ptr += (n - MINBPC(enc));                                       \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_NONASCII:
     case BT_NMSTRT:
     case BT_HEX:
       START_NAME
       break;
-#undef START_NAME
+#  undef START_NAME
     case BT_QUOT:
       if (state != inValue) {
         if (nAtts < attsMax)
           atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_QUOT;
-      }
-      else if (open == BT_QUOT) {
+      } else if (open == BT_QUOT) {
         state = other;
         if (nAtts < attsMax)
           atts[nAtts].valueEnd = ptr;
@@ -1514,8 +1542,7 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
           atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_APOS;
-      }
-      else if (open == BT_APOS) {
+      } else if (open == BT_APOS) {
         state = other;
         if (nAtts < attsMax)
           atts[nAtts].valueEnd = ptr;
@@ -1529,16 +1556,15 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
     case BT_S:
       if (state == inName)
         state = other;
-      else if (state == inValue
-               && nAtts < attsMax
-               && atts[nAtts].normalized
+      else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized
                && (ptr == atts[nAtts].valuePtr
                    || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
                    || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
                    || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
         atts[nAtts].normalized = 0;
       break;
-    case BT_CR: case BT_LF:
+    case BT_CR:
+    case BT_LF:
       /* This case ensures that the first attribute name is counted
          Apart from that we could just change state on the quote. */
       if (state == inName)
@@ -1559,29 +1585,44 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 }
 
 static int PTRFASTCALL
-PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
-{
+PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
   int result = 0;
   /* skip &# */
-  ptr += 2*MINBPC(enc);
+  UNUSED_P(enc);
+  ptr += 2 * MINBPC(enc);
   if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
-    for (ptr += MINBPC(enc);
-         !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
+    for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
          ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       switch (c) {
-      case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
-      case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
+      case ASCII_0:
+      case ASCII_1:
+      case ASCII_2:
+      case ASCII_3:
+      case ASCII_4:
+      case ASCII_5:
+      case ASCII_6:
+      case ASCII_7:
+      case ASCII_8:
+      case ASCII_9:
         result <<= 4;
         result |= (c - ASCII_0);
         break;
-      case ASCII_A: case ASCII_B: case ASCII_C:
-      case ASCII_D: case ASCII_E: case ASCII_F:
+      case ASCII_A:
+      case ASCII_B:
+      case ASCII_C:
+      case ASCII_D:
+      case ASCII_E:
+      case ASCII_F:
         result <<= 4;
         result += 10 + (c - ASCII_A);
         break;
-      case ASCII_a: case ASCII_b: case ASCII_c:
-      case ASCII_d: case ASCII_e: case ASCII_f:
+      case ASCII_a:
+      case ASCII_b:
+      case ASCII_c:
+      case ASCII_d:
+      case ASCII_e:
+      case ASCII_f:
         result <<= 4;
         result += 10 + (c - ASCII_a);
         break;
@@ -1589,9 +1630,8 @@ PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
       if (result >= 0x110000)
         return -1;
     }
-  }
-  else {
-    for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
+  } else {
+    for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       result *= 10;
       result += (c - ASCII_0);
@@ -1603,10 +1643,10 @@ PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
 }
 
 static int PTRCALL
-PREFIX(predefinedEntityName)(const ENCODING *UNUSED_P(enc), const char *ptr,
-                             const char *end)
-{
-  switch ((end - ptr)/MINBPC(enc)) {
+PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
+                             const char *end) {
+  UNUSED_P(enc);
+  switch ((end - ptr) / MINBPC(enc)) {
   case 2:
     if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
       switch (BYTE_TO_ASCII(enc, ptr)) {
@@ -1657,9 +1697,9 @@ PREFIX(predefinedEntityName)(const ENCODING *UNUSED_P(enc), const char *ptr,
 }
 
 static int PTRCALL
-PREFIX(nameMatchesAscii)(const ENCODING *UNUSED_P(enc), const char *ptr1,
-                         const char *end1, const char *ptr2)
-{
+PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
+                         const char *end1, const char *ptr2) {
+  UNUSED_P(enc);
   for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
     if (end1 - ptr1 < MINBPC(enc)) {
       /* This line cannot be executed.  The incoming data has already
@@ -1669,27 +1709,30 @@ PREFIX(nameMatchesAscii)(const ENCODING *UNUSED_P(enc), const char *ptr1,
        */
       return 0; /* LCOV_EXCL_LINE */
     }
-    if (!CHAR_MATCHES(enc, ptr1, *ptr2))
+    if (! CHAR_MATCHES(enc, ptr1, *ptr2))
       return 0;
   }
   return ptr1 == end1;
 }
 
 static int PTRFASTCALL
-PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
-{
+PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
   const char *start = ptr;
   for (;;) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: ptr += n; break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_NONASCII:
     case BT_NMSTRT:
-#ifdef XML_NS
+#  ifdef XML_NS
     case BT_COLON:
-#endif
+#  endif
     case BT_HEX:
     case BT_DIGIT:
     case BT_NAME:
@@ -1702,9 +1745,8 @@ PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
   }
 }
 
-static const char * PTRFASTCALL
-PREFIX(skipS)(const ENCODING *enc, const char *ptr)
-{
+static const char *PTRFASTCALL
+PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
   for (;;) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_LF:
@@ -1719,19 +1761,18 @@ PREFIX(skipS)(const ENCODING *enc, const char *ptr)
 }
 
 static void PTRCALL
-PREFIX(updatePosition)(const ENCODING *enc,
-                       const char *ptr,
-                       const char *end,
-                       POSITION *pos)
-{
+PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
+                       POSITION *pos) {
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
-#define LEAD_CASE(n) \
-    case BT_LEAD ## n: \
-      ptr += n; \
-      break;
-    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
-#undef LEAD_CASE
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
     case BT_LF:
       pos->columnNumber = (XML_Size)-1;
       pos->lineNumber++;
@@ -1752,12 +1793,12 @@ PREFIX(updatePosition)(const ENCODING *enc,
   }
 }
 
-#undef DO_LEAD_CASE
-#undef MULTIBYTE_CASES
-#undef INVALID_CASES
-#undef CHECK_NAME_CASE
-#undef CHECK_NAME_CASES
-#undef CHECK_NMSTRT_CASE
-#undef CHECK_NMSTRT_CASES
+#  undef DO_LEAD_CASE
+#  undef MULTIBYTE_CASES
+#  undef INVALID_CASES
+#  undef CHECK_NAME_CASE
+#  undef CHECK_NAME_CASES
+#  undef CHECK_NMSTRT_CASE
+#  undef CHECK_NMSTRT_CASES
 
 #endif /* XML_TOK_IMPL_C */
diff --git a/contrib/expat/lib/xmltok_impl.h b/contrib/expat/lib/xmltok_impl.h
index a6420f48eedc..e925dbc7e2c8 100644
--- a/contrib/expat/lib/xmltok_impl.h
+++ b/contrib/expat/lib/xmltok_impl.h
@@ -31,43 +31,43 @@
 */
 
 enum {
-  BT_NONXML,
-  BT_MALFORM,
-  BT_LT,
-  BT_AMP,
-  BT_RSQB,
-  BT_LEAD2,
-  BT_LEAD3,
-  BT_LEAD4,
-  BT_TRAIL,
-  BT_CR,
-  BT_LF,
-  BT_GT,
-  BT_QUOT,
-  BT_APOS,
-  BT_EQUALS,
-  BT_QUEST,
-  BT_EXCL,
-  BT_SOL,
-  BT_SEMI,
-  BT_NUM,
-  BT_LSQB,
-  BT_S,
-  BT_NMSTRT,
-  BT_COLON,
-  BT_HEX,
-  BT_DIGIT,
-  BT_NAME,
-  BT_MINUS,
-  BT_OTHER, /* known not to be a name or name start character */
+  BT_NONXML,   /* e.g. noncharacter-FFFF */
+  BT_MALFORM,  /* illegal, with regard to encoding */
+  BT_LT,       /* less than = "<" */
+  BT_AMP,      /* ampersand = "&" */
+  BT_RSQB,     /* right square bracket = "[" */
+  BT_LEAD2,    /* lead byte of a 2-byte UTF-8 character */
+  BT_LEAD3,    /* lead byte of a 3-byte UTF-8 character */
+  BT_LEAD4,    /* lead byte of a 4-byte UTF-8 character */
+  BT_TRAIL,    /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
+  BT_CR,       /* carriage return = "\r" */
+  BT_LF,       /* line feed = "\n" */
+  BT_GT,       /* greater than = ">" */
+  BT_QUOT,     /* quotation character = "\"" */
+  BT_APOS,     /* aposthrophe = "'" */
+  BT_EQUALS,   /* equal sign = "=" */
+  BT_QUEST,    /* question mark = "?" */
+  BT_EXCL,     /* exclamation mark = "!" */
+  BT_SOL,      /* solidus, slash = "/" */
+  BT_SEMI,     /* semicolon = ";" */
+  BT_NUM,      /* number sign = "#" */
+  BT_LSQB,     /* left square bracket = "[" */
+  BT_S,        /* white space, e.g. "\t", " "[, "\r"] */
+  BT_NMSTRT,   /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
+  BT_COLON,    /* colon = ":" */
+  BT_HEX,      /* hex letter = "A".."F" + "a".."f" */
+  BT_DIGIT,    /* digit = "0".."9" */
+  BT_NAME,     /* dot and middle dot = "." + chr(0xb7) */
+  BT_MINUS,    /* minus = "-" */
+  BT_OTHER,    /* known not to be a name or name start character */
   BT_NONASCII, /* might be a name or name start character */
-  BT_PERCNT,
-  BT_LPAR,
-  BT_RPAR,
-  BT_AST,
-  BT_PLUS,
-  BT_COMMA,
-  BT_VERBAR
+  BT_PERCNT,   /* percent sign = "%" */
+  BT_LPAR,     /* left parenthesis = "(" */
+  BT_RPAR,     /* right parenthesis = "(" */
+  BT_AST,      /* asterisk = "*" */
+  BT_PLUS,     /* plus sign = "+" */
+  BT_COMMA,    /* comma = "," */
+  BT_VERBAR    /* vertical bar = "|" */
 };
 
 #include <stddef.h>
diff --git a/contrib/expat/lib/xmltok_ns.c b/contrib/expat/lib/xmltok_ns.c
index 23d31e8e4249..919c74e9f97f 100644
--- a/contrib/expat/lib/xmltok_ns.c
+++ b/contrib/expat/lib/xmltok_ns.c
@@ -33,56 +33,47 @@
 #ifdef XML_TOK_NS_C
 
 const ENCODING *
-NS(XmlGetUtf8InternalEncoding)(void)
-{
+NS(XmlGetUtf8InternalEncoding)(void) {
   return &ns(internal_utf8_encoding).enc;
 }
 
 const ENCODING *
-NS(XmlGetUtf16InternalEncoding)(void)
-{
-#if BYTEORDER == 1234
+NS(XmlGetUtf16InternalEncoding)(void) {
+#  if BYTEORDER == 1234
   return &ns(internal_little2_encoding).enc;
-#elif BYTEORDER == 4321
+#  elif BYTEORDER == 4321
   return &ns(internal_big2_encoding).enc;
-#else
+#  else
   const short n = 1;
-  return (*(const char *)&n
-          ? &ns(internal_little2_encoding).enc
-          : &ns(internal_big2_encoding).enc);
-#endif
+  return (*(const char *)&n ? &ns(internal_little2_encoding).enc
+                            : &ns(internal_big2_encoding).enc);
+#  endif
 }
 
-static const ENCODING * const NS(encodings)[] = {
-  &ns(latin1_encoding).enc,
-  &ns(ascii_encoding).enc,
-  &ns(utf8_encoding).enc,
-  &ns(big2_encoding).enc,
-  &ns(big2_encoding).enc,
-  &ns(little2_encoding).enc,
-  &ns(utf8_encoding).enc /* NO_ENC */
+static const ENCODING *const NS(encodings)[] = {
+    &ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
+    &ns(utf8_encoding).enc,   &ns(big2_encoding).enc,
+    &ns(big2_encoding).enc,   &ns(little2_encoding).enc,
+    &ns(utf8_encoding).enc /* NO_ENC */
 };
 
 static int PTRCALL
 NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
-                   const char **nextTokPtr)
-{
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
-                  XML_PROLOG_STATE, ptr, end, nextTokPtr);
+                   const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
+                  ptr, end, nextTokPtr);
 }
 
 static int PTRCALL
 NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
-                    const char **nextTokPtr)
-{
-  return initScan(NS(encodings), (const INIT_ENCODING *)enc,
-                  XML_CONTENT_STATE, ptr, end, nextTokPtr);
+                    const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
+                  ptr, end, nextTokPtr);
 }
 
 int
 NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
-                    const char *name)
-{
+                    const char *name) {
   int i = getEncodingIndex(name);
   if (i == UNKNOWN_ENC)
     return 0;
@@ -96,9 +87,8 @@ NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
 }
 
 static const ENCODING *
-NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
-{
-#define ENCODING_MAX 128
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
+#  define ENCODING_MAX 128
   char buf[ENCODING_MAX];
   char *p = buf;
   int i;
@@ -115,28 +105,14 @@ NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
 }
 
 int
-NS(XmlParseXmlDecl)(int isGeneralTextEntity,
-                    const ENCODING *enc,
-                    const char *ptr,
-                    const char *end,
-                    const char **badPtr,
-                    const char **versionPtr,
-                    const char **versionEndPtr,
-                    const char **encodingName,
-                    const ENCODING **encoding,
-                    int *standalone)
-{
-  return doParseXmlDecl(NS(findEncoding),
-                        isGeneralTextEntity,
-                        enc,
-                        ptr,
-                        end,
-                        badPtr,
-                        versionPtr,
-                        versionEndPtr,
-                        encodingName,
-                        encoding,
-                        standalone);
+NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
+                    const char **encodingName, const ENCODING **encoding,
+                    int *standalone) {
+  return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
+                        badPtr, versionPtr, versionEndPtr, encodingName,
+                        encoding, standalone);
 }
 
 #endif /* XML_TOK_NS_C */
diff --git a/contrib/expat/test-driver-wrapper.sh b/contrib/expat/test-driver-wrapper.sh
index 30b34d547aec..36a185266c68 100755
--- a/contrib/expat/test-driver-wrapper.sh
+++ b/contrib/expat/test-driver-wrapper.sh
@@ -1,4 +1,4 @@
-#! /bin/bash
+#! /usr/bin/env bash
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
diff --git a/contrib/expat/tests/Makefile.in b/contrib/expat/tests/Makefile.in
index 723c3a961045..b64e43b80b9c 100644
--- a/contrib/expat/tests/Makefile.in
+++ b/contrib/expat/tests/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -125,7 +125,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -169,7 +176,10 @@ am__v_at_0 = @
 am__v_at_1 = 
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/conftools/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/chardata.Po ./$(DEPDIR)/memcheck.Po \
+	./$(DEPDIR)/minicheck.Po ./$(DEPDIR)/runtests.Po \
+	./$(DEPDIR)/runtestspp.Po ./$(DEPDIR)/structdata.Po
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -231,7 +241,7 @@ am__recursive_targets = \
   $(RECURSIVE_CLEAN_TARGETS) \
   $(am__extra_recursive_targets)
 AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
-	check recheck distdir
+	check recheck distdir distdir-am
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 # Read a list of newline-separated strings from the standard input,
 # and print each of them once, without duplicates.  Input order is
@@ -660,8 +670,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -673,14 +683,6 @@ $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 
-clean-noinstLIBRARIES:
-	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
-
-libruntests.a: $(libruntests_a_OBJECTS) $(libruntests_a_DEPENDENCIES) $(EXTRA_libruntests_a_DEPENDENCIES) 
-	$(AM_V_at)-rm -f libruntests.a
-	$(AM_V_AR)$(libruntests_a_AR) libruntests.a $(libruntests_a_OBJECTS) $(libruntests_a_LIBADD)
-	$(AM_V_at)$(RANLIB) libruntests.a
-
 clean-checkPROGRAMS:
 	@list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \
 	echo " rm -f" $$list; \
@@ -690,6 +692,14 @@ clean-checkPROGRAMS:
 	echo " rm -f" $$list; \
 	rm -f $$list
 
+clean-noinstLIBRARIES:
+	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
+
+libruntests.a: $(libruntests_a_OBJECTS) $(libruntests_a_DEPENDENCIES) $(EXTRA_libruntests_a_DEPENDENCIES) 
+	$(AM_V_at)-rm -f libruntests.a
+	$(AM_V_AR)$(libruntests_a_AR) libruntests.a $(libruntests_a_OBJECTS) $(libruntests_a_LIBADD)
+	$(AM_V_at)$(RANLIB) libruntests.a
+
 runtests$(EXEEXT): $(runtests_OBJECTS) $(runtests_DEPENDENCIES) $(EXTRA_runtests_DEPENDENCIES) 
 	@rm -f runtests$(EXEEXT)
 	$(AM_V_CCLD)$(LINK) $(runtests_OBJECTS) $(runtests_LDADD) $(LIBS)
@@ -704,12 +714,18 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/chardata.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcheck.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/minicheck.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtests.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtestspp.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/structdata.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/chardata.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memcheck.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/minicheck.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtests.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/runtestspp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/structdata.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@@ -978,7 +994,7 @@ $(TEST_SUITE_LOG): $(TEST_LOGS)
 	fi;								\
 	$$success || exit 1
 
-check-TESTS:
+check-TESTS: $(check_PROGRAMS)
 	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
 	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
 	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
@@ -1028,7 +1044,10 @@ runtestspp.log: runtestspp$(EXEEXT)
 @am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
 @am__EXEEXT_TRUE@	"$$tst" $(AM_TESTS_FD_REDIRECT)
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -1129,7 +1148,12 @@ clean-am: clean-checkPROGRAMS clean-generic clean-libtool \
 	clean-noinstLIBRARIES mostlyclean-am
 
 distclean: distclean-recursive
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/chardata.Po
+	-rm -f ./$(DEPDIR)/memcheck.Po
+	-rm -f ./$(DEPDIR)/minicheck.Po
+	-rm -f ./$(DEPDIR)/runtests.Po
+	-rm -f ./$(DEPDIR)/runtestspp.Po
+	-rm -f ./$(DEPDIR)/structdata.Po
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -1175,7 +1199,12 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-recursive
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/chardata.Po
+	-rm -f ./$(DEPDIR)/memcheck.Po
+	-rm -f ./$(DEPDIR)/minicheck.Po
+	-rm -f ./$(DEPDIR)/runtests.Po
+	-rm -f ./$(DEPDIR)/runtestspp.Po
+	-rm -f ./$(DEPDIR)/structdata.Po
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -1196,20 +1225,21 @@ uninstall-am:
 
 .MAKE: $(am__recursive_targets) check-am install-am install-strip
 
-.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am check \
-	check-TESTS check-am clean clean-checkPROGRAMS clean-generic \
-	clean-libtool clean-noinstLIBRARIES cscopelist-am ctags \
-	ctags-am distclean distclean-compile distclean-generic \
-	distclean-libtool distclean-tags distdir dvi dvi-am html \
-	html-am info info-am install install-am install-data \
-	install-data-am install-dvi install-dvi-am install-exec \
-	install-exec-am install-html install-html-am install-info \
-	install-info-am install-man install-pdf install-pdf-am \
-	install-ps install-ps-am install-strip installcheck \
-	installcheck-am installdirs installdirs-am maintainer-clean \
-	maintainer-clean-generic mostlyclean mostlyclean-compile \
-	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
-	recheck tags tags-am uninstall uninstall-am
+.PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
+	am--depfiles check check-TESTS check-am clean \
+	clean-checkPROGRAMS clean-generic clean-libtool \
+	clean-noinstLIBRARIES cscopelist-am ctags ctags-am distclean \
+	distclean-compile distclean-generic distclean-libtool \
+	distclean-tags distdir dvi dvi-am html html-am info info-am \
+	install install-am install-data install-data-am install-dvi \
+	install-dvi-am install-exec install-exec-am install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	installdirs-am maintainer-clean maintainer-clean-generic \
+	mostlyclean mostlyclean-compile mostlyclean-generic \
+	mostlyclean-libtool pdf pdf-am ps ps-am recheck tags tags-am \
+	uninstall uninstall-am
 
 .PRECIOUS: Makefile
 
diff --git a/contrib/expat/tests/benchmark/Makefile.in b/contrib/expat/tests/benchmark/Makefile.in
index d21998cc868c..410ee04106d2 100644
--- a/contrib/expat/tests/benchmark/Makefile.in
+++ b/contrib/expat/tests/benchmark/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -124,7 +124,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -155,7 +162,8 @@ am__v_at_0 = @
 am__v_at_1 = 
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/conftools/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/benchmark.Po
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -357,8 +365,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -389,7 +397,13 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/benchmark.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/benchmark.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@@ -470,7 +484,10 @@ cscopelist-am: $(am__tagged_files)
 distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -540,7 +557,7 @@ clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
 	mostlyclean-am
 
 distclean: distclean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/benchmark.Po
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -586,7 +603,7 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/benchmark.Po
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -607,9 +624,9 @@ uninstall-am:
 
 .MAKE: install-am install-strip
 
-.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean clean-generic \
-	clean-libtool clean-noinstPROGRAMS cscopelist-am ctags \
-	ctags-am distclean distclean-compile distclean-generic \
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
+	clean-generic clean-libtool clean-noinstPROGRAMS cscopelist-am \
+	ctags ctags-am distclean distclean-compile distclean-generic \
 	distclean-libtool distclean-tags distdir dvi dvi-am html \
 	html-am info info-am install install-am install-data \
 	install-data-am install-dvi install-dvi-am install-exec \
diff --git a/contrib/expat/tests/benchmark/benchmark.c b/contrib/expat/tests/benchmark/benchmark.c
index 0c9155455a47..fda8268f189f 100644
--- a/contrib/expat/tests/benchmark/benchmark.c
+++ b/contrib/expat/tests/benchmark/benchmark.c
@@ -37,43 +37,40 @@
 #include "expat.h"
 
 #ifdef XML_LARGE_SIZE
-# define XML_FMT_INT_MOD "ll"
+#  define XML_FMT_INT_MOD "ll"
 #else
-# define XML_FMT_INT_MOD "l"
+#  define XML_FMT_INT_MOD "l"
 #endif
 
 #ifdef XML_UNICODE_WCHAR_T
-# define XML_FMT_STR "ls"
+#  define XML_FMT_STR "ls"
 #else
-# define XML_FMT_STR "s"
+#  define XML_FMT_STR "s"
 #endif
 
 static void
-usage(const char *prog, int rc)
-{
-  fprintf(stderr,
-          "usage: %s [-n] filename bufferSize nr_of_loops\n", prog);
+usage(const char *prog, int rc) {
+  fprintf(stderr, "usage: %s [-n] filename bufferSize nr_of_loops\n", prog);
   exit(rc);
 }
 
-int main (int argc, char *argv[]) 
-{
-  XML_Parser  parser;
-  char        *XMLBuf, *XMLBufEnd, *XMLBufPtr;
-  FILE        *fd;
+int
+main(int argc, char *argv[]) {
+  XML_Parser parser;
+  char *XMLBuf, *XMLBufEnd, *XMLBufPtr;
+  FILE *fd;
   struct stat fileAttr;
-  int         nrOfLoops, bufferSize, fileSize, i, isFinal;
-  int         j = 0, ns = 0;
-  clock_t     tstart, tend;
-  double      cpuTime = 0.0;
+  int nrOfLoops, bufferSize, fileSize, i, isFinal;
+  int j = 0, ns = 0;
+  clock_t tstart, tend;
+  double cpuTime = 0.0;
 
   if (argc > 1) {
     if (argv[1][0] == '-') {
       if (argv[1][1] == 'n' && argv[1][2] == '\0') {
         ns = 1;
         j = 1;
-      }
-      else
+      } else
         usage(argv[0], 1);
     }
   }
@@ -81,29 +78,28 @@ int main (int argc, char *argv[])
   if (argc != j + 4)
     usage(argv[0], 1);
 
-  if (stat (argv[j + 1], &fileAttr) != 0) {
-    fprintf (stderr, "could not access file '%s'\n", argv[j + 1]);
+  if (stat(argv[j + 1], &fileAttr) != 0) {
+    fprintf(stderr, "could not access file '%s'\n", argv[j + 1]);
     return 2;
   }
-  
-  fd = fopen (argv[j + 1], "r");
-  if (!fd) {
-    fprintf (stderr, "could not open file '%s'\n", argv[j + 1]);
+
+  fd = fopen(argv[j + 1], "r");
+  if (! fd) {
+    fprintf(stderr, "could not open file '%s'\n", argv[j + 1]);
     exit(2);
   }
-  
-  bufferSize = atoi (argv[j + 2]);
-  nrOfLoops = atoi (argv[j + 3]);
+
+  bufferSize = atoi(argv[j + 2]);
+  nrOfLoops = atoi(argv[j + 3]);
   if (bufferSize <= 0 || nrOfLoops <= 0) {
-    fprintf (stderr, 
-             "buffer size and nr of loops must be greater than zero.\n");
+    fprintf(stderr, "buffer size and nr of loops must be greater than zero.\n");
     exit(3);
   }
 
-  XMLBuf = malloc (fileAttr.st_size);
-  fileSize = fread (XMLBuf, sizeof (char), fileAttr.st_size, fd);
-  fclose (fd);
-  
+  XMLBuf = malloc(fileAttr.st_size);
+  fileSize = fread(XMLBuf, sizeof(char), fileAttr.st_size, fd);
+  fclose(fd);
+
   if (ns)
     parser = XML_ParserCreateNS(NULL, '!');
   else
@@ -121,29 +117,29 @@ int main (int argc, char *argv[])
         isFinal = 1;
       else
         parseBufferSize = bufferSize;
-      if (!XML_Parse (parser, XMLBufPtr, parseBufferSize, isFinal)) {
-        fprintf (stderr,
-                 "error '%" XML_FMT_STR "' at line %" XML_FMT_INT_MOD   \
-                     "u character %" XML_FMT_INT_MOD "u\n",
-                 XML_ErrorString (XML_GetErrorCode (parser)),
-                 XML_GetCurrentLineNumber (parser),
-                 XML_GetCurrentColumnNumber (parser));
-        free (XMLBuf);
-        XML_ParserFree (parser);
-        exit (4);
+      if (! XML_Parse(parser, XMLBufPtr, parseBufferSize, isFinal)) {
+        fprintf(stderr,
+                "error '%" XML_FMT_STR "' at line %" XML_FMT_INT_MOD
+                "u character %" XML_FMT_INT_MOD "u\n",
+                XML_ErrorString(XML_GetErrorCode(parser)),
+                XML_GetCurrentLineNumber(parser),
+                XML_GetCurrentColumnNumber(parser));
+        free(XMLBuf);
+        XML_ParserFree(parser);
+        exit(4);
       }
       XMLBufPtr += bufferSize;
-    } while (!isFinal);
+    } while (! isFinal);
     tend = clock();
-    cpuTime += ((double) (tend - tstart)) / CLOCKS_PER_SEC;
+    cpuTime += ((double)(tend - tstart)) / CLOCKS_PER_SEC;
     XML_ParserReset(parser, NULL);
     i++;
   }
 
-  XML_ParserFree (parser);
-  free (XMLBuf);
-      
-  printf ("%d loops, with buffer size %d. Average time per loop: %f\n", 
-          nrOfLoops, bufferSize, cpuTime / (double) nrOfLoops);
+  XML_ParserFree(parser);
+  free(XMLBuf);
+
+  printf("%d loops, with buffer size %d. Average time per loop: %f\n",
+         nrOfLoops, bufferSize, cpuTime / (double)nrOfLoops);
   return 0;
 }
diff --git a/contrib/expat/tests/chardata.c b/contrib/expat/tests/chardata.c
index 53e7333ff172..75a50166ec52 100644
--- a/contrib/expat/tests/chardata.c
+++ b/contrib/expat/tests/chardata.c
@@ -31,7 +31,7 @@
 */
 
 #ifdef HAVE_EXPAT_CONFIG_H
-# include <expat_config.h>
+#  include <expat_config.h>
 #endif
 #include "minicheck.h"
 
@@ -41,65 +41,58 @@
 
 #include "chardata.h"
 
-
 static int
-xmlstrlen(const XML_Char *s)
-{
-    int len = 0;
-    assert(s != NULL);
-    while (s[len] != 0)
-        ++len;
-    return len;
+xmlstrlen(const XML_Char *s) {
+  int len = 0;
+  assert(s != NULL);
+  while (s[len] != 0)
+    ++len;
+  return len;
 }
 
-
 void
-CharData_Init(CharData *storage)
-{
-    assert(storage != NULL);
-    storage->count = -1;
+CharData_Init(CharData *storage) {
+  assert(storage != NULL);
+  storage->count = -1;
 }
 
 void
-CharData_AppendXMLChars(CharData *storage, const XML_Char *s, int len)
-{
-    int maxchars;
+CharData_AppendXMLChars(CharData *storage, const XML_Char *s, int len) {
+  int maxchars;
 
-    assert(storage != NULL);
-    assert(s != NULL);
-    maxchars = sizeof(storage->data) / sizeof(storage->data[0]);
-    if (storage->count < 0)
-        storage->count = 0;
-    if (len < 0)
-        len = xmlstrlen(s);
-    if ((len + storage->count) > maxchars) {
-        len = (maxchars - storage->count);
-    }
-    if (len + storage->count < (int)sizeof(storage->data)) {
-        memcpy(storage->data + storage->count, s,
-               len * sizeof(storage->data[0]));
-        storage->count += len;
-    }
+  assert(storage != NULL);
+  assert(s != NULL);
+  maxchars = sizeof(storage->data) / sizeof(storage->data[0]);
+  if (storage->count < 0)
+    storage->count = 0;
+  if (len < 0)
+    len = xmlstrlen(s);
+  if ((len + storage->count) > maxchars) {
+    len = (maxchars - storage->count);
+  }
+  if (len + storage->count < (int)sizeof(storage->data)) {
+    memcpy(storage->data + storage->count, s, len * sizeof(storage->data[0]));
+    storage->count += len;
+  }
 }
 
 int
-CharData_CheckXMLChars(CharData *storage, const XML_Char *expected)
-{
-    char buffer[1024];
-    int len = xmlstrlen(expected);
-    int count;
+CharData_CheckXMLChars(CharData *storage, const XML_Char *expected) {
+  char buffer[1024];
+  int len = xmlstrlen(expected);
+  int count;
 
-    assert(storage != NULL);
-    count = (storage->count < 0) ? 0 : storage->count;
-    if (len != count) {
-        sprintf(buffer, "wrong number of data characters: got %d, expected %d",
-                count, len);
-        fail(buffer);
-        return 0;
-    }
-    if (memcmp(expected, storage->data, len * sizeof(storage->data[0])) != 0) {
-        fail("got bad data bytes");
-        return 0;
-    }
-    return 1;
+  assert(storage != NULL);
+  count = (storage->count < 0) ? 0 : storage->count;
+  if (len != count) {
+    sprintf(buffer, "wrong number of data characters: got %d, expected %d",
+            count, len);
+    fail(buffer);
+    return 0;
+  }
+  if (memcmp(expected, storage->data, len * sizeof(storage->data[0])) != 0) {
+    fail("got bad data bytes");
+    return 0;
+  }
+  return 1;
 }
diff --git a/contrib/expat/tests/chardata.h b/contrib/expat/tests/chardata.h
index d3ad869d83ed..4001b9b9d157 100644
--- a/contrib/expat/tests/chardata.h
+++ b/contrib/expat/tests/chardata.h
@@ -36,27 +36,24 @@ extern "C" {
 #endif
 
 #ifndef XML_CHARDATA_H
-#define XML_CHARDATA_H 1
-
-#ifndef XML_VERSION
-#include "expat.h"                      /* need XML_Char */
-#endif
+#  define XML_CHARDATA_H 1
 
+#  ifndef XML_VERSION
+#    include "expat.h" /* need XML_Char */
+#  endif
 
 typedef struct {
-    int count;                          /* # of chars, < 0 if not set */
-    XML_Char data[2048];
+  int count; /* # of chars, < 0 if not set */
+  XML_Char data[2048];
 } CharData;
 
-
 void CharData_Init(CharData *storage);
 
 void CharData_AppendXMLChars(CharData *storage, const XML_Char *s, int len);
 
 int CharData_CheckXMLChars(CharData *storage, const XML_Char *s);
 
-
-#endif  /* XML_CHARDATA_H */
+#endif /* XML_CHARDATA_H */
 
 #ifdef __cplusplus
 }
diff --git a/contrib/expat/tests/memcheck.c b/contrib/expat/tests/memcheck.c
index 23e9fdf43bc6..41355f6c8d91 100644
--- a/contrib/expat/tests/memcheck.c
+++ b/contrib/expat/tests/memcheck.c
@@ -34,17 +34,16 @@
 #include <stdlib.h>
 #include "memcheck.h"
 
-
 /* Structures to keep track of what has been allocated.  Speed isn't a
  * big issue for the tests this is required for, so we will use a
  * doubly-linked list to make deletion easier.
  */
 
 typedef struct allocation_entry {
-    struct allocation_entry * next;
-    struct allocation_entry * prev;
-    void * allocation;
-    size_t num_bytes;
+  struct allocation_entry *next;
+  struct allocation_entry *prev;
+  void *allocation;
+  size_t num_bytes;
 } AllocationEntry;
 
 static AllocationEntry *alloc_head = NULL;
@@ -52,147 +51,140 @@ static AllocationEntry *alloc_tail = NULL;
 
 static AllocationEntry *find_allocation(void *ptr);
 
-
 /* Allocate some memory and keep track of it. */
 void *
-tracking_malloc(size_t size)
-{
-    AllocationEntry *entry = malloc(sizeof(AllocationEntry));
-
-    if (entry == NULL) {
-        printf("Allocator failure\n");
-        return NULL;
-    }
-    entry->num_bytes = size;
-    entry->allocation = malloc(size);
-    if (entry->allocation == NULL) {
-        free(entry);
-        return NULL;
-    }
-    entry->next = NULL;
+tracking_malloc(size_t size) {
+  AllocationEntry *entry = malloc(sizeof(AllocationEntry));
 
-    /* Add to the list of allocations */
-    if (alloc_head == NULL) {
-        entry->prev = NULL;
-        alloc_head = alloc_tail = entry;
-    } else {
-        entry->prev = alloc_tail;
-        alloc_tail->next = entry;
-        alloc_tail = entry;
-    }
-
-    return entry->allocation;
+  if (entry == NULL) {
+    printf("Allocator failure\n");
+    return NULL;
+  }
+  entry->num_bytes = size;
+  entry->allocation = malloc(size);
+  if (entry->allocation == NULL) {
+    free(entry);
+    return NULL;
+  }
+  entry->next = NULL;
+
+  /* Add to the list of allocations */
+  if (alloc_head == NULL) {
+    entry->prev = NULL;
+    alloc_head = alloc_tail = entry;
+  } else {
+    entry->prev = alloc_tail;
+    alloc_tail->next = entry;
+    alloc_tail = entry;
+  }
+
+  return entry->allocation;
 }
 
 static AllocationEntry *
-find_allocation(void *ptr)
-{
-    AllocationEntry *entry;
-
-    for (entry = alloc_head; entry != NULL; entry = entry->next) {
-        if (entry->allocation == ptr) {
-            return entry;
-        }
+find_allocation(void *ptr) {
+  AllocationEntry *entry;
+
+  for (entry = alloc_head; entry != NULL; entry = entry->next) {
+    if (entry->allocation == ptr) {
+      return entry;
     }
-    return NULL;
+  }
+  return NULL;
 }
 
 /* Free some memory and remove the tracking for it */
 void
-tracking_free(void *ptr)
-{
-    AllocationEntry *entry;
-
-    if (ptr == NULL) {
-        /* There won't be an entry for this */
-        return;
-    }
-
-    entry = find_allocation(ptr);
-    if (entry != NULL) {
-        /* This is the relevant allocation.  Unlink it */
-        if (entry->prev != NULL)
-            entry->prev->next = entry->next;
-        else
-            alloc_head = entry->next;
-        if (entry->next != NULL)
-            entry->next->prev = entry->prev;
-        else
-            alloc_tail = entry->next;
-        free(entry);
-    } else {
-        printf("Attempting to free unallocated memory at %p\n", ptr);
-    }
-    free(ptr);
+tracking_free(void *ptr) {
+  AllocationEntry *entry;
+
+  if (ptr == NULL) {
+    /* There won't be an entry for this */
+    return;
+  }
+
+  entry = find_allocation(ptr);
+  if (entry != NULL) {
+    /* This is the relevant allocation.  Unlink it */
+    if (entry->prev != NULL)
+      entry->prev->next = entry->next;
+    else
+      alloc_head = entry->next;
+    if (entry->next != NULL)
+      entry->next->prev = entry->prev;
+    else
+      alloc_tail = entry->next;
+    free(entry);
+  } else {
+    printf("Attempting to free unallocated memory at %p\n", ptr);
+  }
+  free(ptr);
 }
 
 /* Reallocate some memory and keep track of it */
 void *
-tracking_realloc(void *ptr, size_t size)
-{
-    AllocationEntry *entry;
+tracking_realloc(void *ptr, size_t size) {
+  AllocationEntry *entry;
+
+  if (ptr == NULL) {
+    /* By definition, this is equivalent to malloc(size) */
+    return tracking_malloc(size);
+  }
+  if (size == 0) {
+    /* By definition, this is equivalent to free(ptr) */
+    tracking_free(ptr);
+    return NULL;
+  }
 
-    if (ptr == NULL) {
-        /* By definition, this is equivalent to malloc(size) */
-        return tracking_malloc(size);
+  /* Find the allocation entry for this memory */
+  entry = find_allocation(ptr);
+  if (entry == NULL) {
+    printf("Attempting to realloc unallocated memory at %p\n", ptr);
+    entry = malloc(sizeof(AllocationEntry));
+    if (entry == NULL) {
+      printf("Reallocator failure\n");
+      return NULL;
     }
-    if (size == 0) {
-        /* By definition, this is equivalent to free(ptr) */
-        tracking_free(ptr);
-        return NULL;
+    entry->allocation = realloc(ptr, size);
+    if (entry->allocation == NULL) {
+      free(entry);
+      return NULL;
     }
 
-    /* Find the allocation entry for this memory */
-    entry = find_allocation(ptr);
-    if (entry == NULL) {
-        printf("Attempting to realloc unallocated memory at %p\n", ptr);
-        entry = malloc(sizeof(AllocationEntry));
-        if (entry == NULL) {
-            printf("Reallocator failure\n");
-            return NULL;
-        }
-        entry->allocation = realloc(ptr, size);
-        if (entry->allocation == NULL) {
-            free(entry);
-            return NULL;
-        }
-
-        /* Add to the list of allocations */
-        entry->next = NULL;
-        if (alloc_head == NULL) {
-            entry->prev = NULL;
-            alloc_head = alloc_tail = entry;
-        } else {
-            entry->prev = alloc_tail;
-            alloc_tail->next = entry;
-            alloc_tail = entry;
-        }
+    /* Add to the list of allocations */
+    entry->next = NULL;
+    if (alloc_head == NULL) {
+      entry->prev = NULL;
+      alloc_head = alloc_tail = entry;
     } else {
-        entry->allocation = realloc(ptr, size);
-        if (entry->allocation == NULL) {
-            /* Realloc semantics say the original is still allocated */
-            entry->allocation = ptr;
-            return NULL;
-        }
+      entry->prev = alloc_tail;
+      alloc_tail->next = entry;
+      alloc_tail = entry;
+    }
+  } else {
+    entry->allocation = realloc(ptr, size);
+    if (entry->allocation == NULL) {
+      /* Realloc semantics say the original is still allocated */
+      entry->allocation = ptr;
+      return NULL;
     }
+  }
 
-    entry->num_bytes = size;
-    return entry->allocation;
+  entry->num_bytes = size;
+  return entry->allocation;
 }
 
 int
-tracking_report(void)
-{
-    AllocationEntry *entry;
-
-    if (alloc_head == NULL)
-        return 1;
-
-    /* Otherwise we have allocations that haven't been freed */
-    for (entry = alloc_head; entry != NULL; entry = entry->next)
-    {
-        printf("Allocated %lu bytes at %p\n",
-                (long unsigned)entry->num_bytes, entry->allocation);
-    }
-    return 0;
+tracking_report(void) {
+  AllocationEntry *entry;
+
+  if (alloc_head == NULL)
+    return 1;
+
+  /* Otherwise we have allocations that haven't been freed */
+  for (entry = alloc_head; entry != NULL; entry = entry->next) {
+    printf("Allocated %lu bytes at %p\n", (long unsigned)entry->num_bytes,
+           entry->allocation);
+  }
+  return 0;
 }
diff --git a/contrib/expat/tests/memcheck.h b/contrib/expat/tests/memcheck.h
index 1cc4848280b4..4d20f4bb972d 100644
--- a/contrib/expat/tests/memcheck.h
+++ b/contrib/expat/tests/memcheck.h
@@ -36,7 +36,7 @@ extern "C" {
 #endif
 
 #ifndef XML_MEMCHECK_H
-#define XML_MEMCHECK_H 1
+#  define XML_MEMCHECK_H 1
 
 /* Allocation declarations */
 
diff --git a/contrib/expat/tests/minicheck.c b/contrib/expat/tests/minicheck.c
index be1e37e761b7..a5a1efb159f5 100644
--- a/contrib/expat/tests/minicheck.c
+++ b/contrib/expat/tests/minicheck.c
@@ -40,100 +40,91 @@
 #include <assert.h>
 #include <string.h>
 
-#include "internal.h"  /* for UNUSED_P only */
+#include "internal.h" /* for UNUSED_P only */
 #include "minicheck.h"
 
 Suite *
-suite_create(const char *name)
-{
-    Suite *suite = (Suite *) calloc(1, sizeof(Suite));
-    if (suite != NULL) {
-        suite->name = name;
-    }
-    return suite;
+suite_create(const char *name) {
+  Suite *suite = (Suite *)calloc(1, sizeof(Suite));
+  if (suite != NULL) {
+    suite->name = name;
+  }
+  return suite;
 }
 
 TCase *
-tcase_create(const char *name)
-{
-    TCase *tc = (TCase *) calloc(1, sizeof(TCase));
-    if (tc != NULL) {
-        tc->name = name;
-    }
-    return tc;
+tcase_create(const char *name) {
+  TCase *tc = (TCase *)calloc(1, sizeof(TCase));
+  if (tc != NULL) {
+    tc->name = name;
+  }
+  return tc;
 }
 
 void
-suite_add_tcase(Suite *suite, TCase *tc) 
-{
-    assert(suite != NULL);
-    assert(tc != NULL);
-    assert(tc->next_tcase == NULL);
-
-    tc->next_tcase = suite->tests;
-    suite->tests = tc;
+suite_add_tcase(Suite *suite, TCase *tc) {
+  assert(suite != NULL);
+  assert(tc != NULL);
+  assert(tc->next_tcase == NULL);
+
+  tc->next_tcase = suite->tests;
+  suite->tests = tc;
 }
 
 void
-tcase_add_checked_fixture(TCase *tc,
-                          tcase_setup_function setup,
-                          tcase_teardown_function teardown)
-{
-    assert(tc != NULL);
-    tc->setup = setup;
-    tc->teardown = teardown;
+tcase_add_checked_fixture(TCase *tc, tcase_setup_function setup,
+                          tcase_teardown_function teardown) {
+  assert(tc != NULL);
+  tc->setup = setup;
+  tc->teardown = teardown;
 }
 
 void
-tcase_add_test(TCase *tc, tcase_test_function test)
-{
-    assert(tc != NULL);
-    if (tc->allocated == tc->ntests) {
-        int nalloc = tc->allocated + 100;
-        size_t new_size = sizeof(tcase_test_function) * nalloc;
-        tcase_test_function *new_tests = realloc(tc->tests, new_size);
-        assert(new_tests != NULL);
-        tc->tests = new_tests;
-        tc->allocated = nalloc;
-    }
-    tc->tests[tc->ntests] = test;
-    tc->ntests++;
+tcase_add_test(TCase *tc, tcase_test_function test) {
+  assert(tc != NULL);
+  if (tc->allocated == tc->ntests) {
+    int nalloc = tc->allocated + 100;
+    size_t new_size = sizeof(tcase_test_function) * nalloc;
+    tcase_test_function *new_tests = realloc(tc->tests, new_size);
+    assert(new_tests != NULL);
+    tc->tests = new_tests;
+    tc->allocated = nalloc;
+  }
+  tc->tests[tc->ntests] = test;
+  tc->ntests++;
 }
 
 static void
-tcase_free(TCase *tc)
-{
-    if (! tc) {
-        return;
-    }
+tcase_free(TCase *tc) {
+  if (! tc) {
+    return;
+  }
 
-    free(tc->tests);
-    free(tc);
+  free(tc->tests);
+  free(tc);
 }
 
 static void
-suite_free(Suite *suite)
-{
-    if (! suite) {
-        return;
-    }
-
-    while (suite->tests != NULL) {
-        TCase *next = suite->tests->next_tcase;
-        tcase_free(suite->tests);
-        suite->tests = next;
-    }
-    free(suite);
+suite_free(Suite *suite) {
+  if (! suite) {
+    return;
+  }
+
+  while (suite->tests != NULL) {
+    TCase *next = suite->tests->next_tcase;
+    tcase_free(suite->tests);
+    suite->tests = next;
+  }
+  free(suite);
 }
 
 SRunner *
-srunner_create(Suite *suite)
-{
-    SRunner *runner = calloc(1, sizeof(SRunner));
-    if (runner != NULL) {
-        runner->suite = suite;
-    }
-    return runner;
+srunner_create(Suite *suite) {
+  SRunner *runner = calloc(1, sizeof(SRunner));
+  if (runner != NULL) {
+    runner->suite = suite;
+  }
+  return runner;
 }
 
 static jmp_buf env;
@@ -143,100 +134,96 @@ static int _check_current_lineno = -1;
 static char const *_check_current_filename = NULL;
 
 void
-_check_set_test_info(char const *function, char const *filename, int lineno)
-{
-    _check_current_function = function;
-    _check_current_lineno = lineno;
-    _check_current_filename = filename;
+_check_set_test_info(char const *function, char const *filename, int lineno) {
+  _check_current_function = function;
+  _check_current_lineno = lineno;
+  _check_current_filename = filename;
 }
 
-
 static void
-add_failure(SRunner *runner, int verbosity)
-{
-    runner->nfailures++;
-    if (verbosity >= CK_VERBOSE) {
-        printf("%s:%d: %s\n", _check_current_filename,
-               _check_current_lineno, _check_current_function);
-    }
+add_failure(SRunner *runner, int verbosity) {
+  runner->nfailures++;
+  if (verbosity >= CK_VERBOSE) {
+    printf("%s:%d: %s\n", _check_current_filename, _check_current_lineno,
+           _check_current_function);
+  }
 }
 
 void
-srunner_run_all(SRunner *runner, int verbosity)
-{
-    Suite *suite;
-    TCase *tc;
-    assert(runner != NULL);
-    suite = runner->suite;
-    tc = suite->tests;
-    while (tc != NULL) {
-        int i;
-        for (i = 0; i < tc->ntests; ++i) {
-            runner->nchecks++;
-
-            if (tc->setup != NULL) {
-                /* setup */
-                if (setjmp(env)) {
-                    add_failure(runner, verbosity);
-                    continue;
-                }
-                tc->setup();
-            }
-            /* test */
-            if (setjmp(env)) {
-                add_failure(runner, verbosity);
-                continue;
-            }
-            (tc->tests[i])();
-
-            /* teardown */
-            if (tc->teardown != NULL) {
-                if (setjmp(env)) {
-                    add_failure(runner, verbosity);
-                    continue;
-                }
-                tc->teardown();
-            }
+srunner_run_all(SRunner *runner, int verbosity) {
+  Suite *suite;
+  TCase *volatile tc;
+  assert(runner != NULL);
+  suite = runner->suite;
+  tc = suite->tests;
+  while (tc != NULL) {
+    volatile int i;
+    for (i = 0; i < tc->ntests; ++i) {
+      runner->nchecks++;
+
+      if (tc->setup != NULL) {
+        /* setup */
+        if (setjmp(env)) {
+          add_failure(runner, verbosity);
+          continue;
         }
-        tc = tc->next_tcase;
-    }
-    if (verbosity) {
-        int passed = runner->nchecks - runner->nfailures;
-        double percentage = ((double) passed) / runner->nchecks;
-        int display = (int) (percentage * 100);
-        printf("%d%%: Checks: %d, Failed: %d\n",
-               display, runner->nchecks, runner->nfailures);
+        tc->setup();
+      }
+      /* test */
+      if (setjmp(env)) {
+        add_failure(runner, verbosity);
+        continue;
+      }
+      (tc->tests[i])();
+
+      /* teardown */
+      if (tc->teardown != NULL) {
+        if (setjmp(env)) {
+          add_failure(runner, verbosity);
+          continue;
+        }
+        tc->teardown();
+      }
     }
+    tc = tc->next_tcase;
+  }
+  if (verbosity) {
+    int passed = runner->nchecks - runner->nfailures;
+    double percentage = ((double)passed) / runner->nchecks;
+    int display = (int)(percentage * 100);
+    printf("%d%%: Checks: %d, Failed: %d\n", display, runner->nchecks,
+           runner->nfailures);
+  }
 }
 
 void
-_fail_unless(int UNUSED_P(condition), const char *UNUSED_P(file), int UNUSED_P(line), const char *msg)
-{
-    /* Always print the error message so it isn't lost.  In this case,
-       we have a failure, so there's no reason to be quiet about what
-       it is.
-    */
-    if (msg != NULL) {
-        const int has_newline = (msg[strlen(msg) - 1] == '\n');
-        fprintf(stderr, "ERROR: %s%s", msg, has_newline ? "" : "\n");
-    }
-    longjmp(env, 1);
+_fail_unless(int condition, const char *file, int line, const char *msg) {
+  /* Always print the error message so it isn't lost.  In this case,
+     we have a failure, so there's no reason to be quiet about what
+     it is.
+  */
+  UNUSED_P(condition);
+  UNUSED_P(file);
+  UNUSED_P(line);
+  if (msg != NULL) {
+    const int has_newline = (msg[strlen(msg) - 1] == '\n');
+    fprintf(stderr, "ERROR: %s%s", msg, has_newline ? "" : "\n");
+  }
+  longjmp(env, 1);
 }
 
 int
-srunner_ntests_failed(SRunner *runner)
-{
-    assert(runner != NULL);
-    return runner->nfailures;
+srunner_ntests_failed(SRunner *runner) {
+  assert(runner != NULL);
+  return runner->nfailures;
 }
 
 void
-srunner_free(SRunner *runner)
-{
-    if (! runner) {
-        return;
-    }
+srunner_free(SRunner *runner) {
+  if (! runner) {
+    return;
+  }
 
-    suite_free(runner->suite);
-    free(runner);
+  suite_free(runner->suite);
+  free(runner);
 }
diff --git a/contrib/expat/tests/minicheck.h b/contrib/expat/tests/minicheck.h
index a2f57ddcad05..88a16584fb5b 100644
--- a/contrib/expat/tests/minicheck.h
+++ b/contrib/expat/tests/minicheck.h
@@ -41,26 +41,29 @@ extern "C" {
 #endif
 
 #define CK_NOFORK 0
-#define CK_FORK   1
+#define CK_FORK 1
 
-#define CK_SILENT  0
-#define CK_NORMAL  1
+#define CK_SILENT 0
+#define CK_NORMAL 1
 #define CK_VERBOSE 2
 
 /* Workaround for Microsoft's compiler and Tru64 Unix systems where the
-   C compiler has a working __func__, but the C++ compiler only has a 
+   C compiler has a working __func__, but the C++ compiler only has a
    working __FUNCTION__.  This could be fixed in configure.in, but it's
    not worth it right now. */
-#if defined (_MSC_VER) || (defined(__osf__) && defined(__cplusplus))
-#define __func__ __FUNCTION__
+#if defined(_MSC_VER) || (defined(__osf__) && defined(__cplusplus))
+#  define __func__ __FUNCTION__
 #endif
 
-#define START_TEST(testname) static void testname(void) { \
-    _check_set_test_info(__func__, __FILE__, __LINE__);   \
+#define START_TEST(testname)                                                   \
+  static void testname(void) {                                                 \
+    _check_set_test_info(__func__, __FILE__, __LINE__);                        \
     {
-#define END_TEST } }
+#define END_TEST                                                               \
+  }                                                                            \
+  }
 
-#define fail(msg)  _fail_unless(0, __FILE__, __LINE__, msg)
+#define fail(msg) _fail_unless(0, __FILE__, __LINE__, msg)
 
 typedef void (*tcase_setup_function)(void);
 typedef void (*tcase_teardown_function)(void);
@@ -71,31 +74,29 @@ typedef struct Suite Suite;
 typedef struct TCase TCase;
 
 struct SRunner {
-    Suite *suite;
-    int nchecks;
-    int nfailures;
+  Suite *suite;
+  int nchecks;
+  int nfailures;
 };
 
 struct Suite {
-    const char *name;
-    TCase *tests;
+  const char *name;
+  TCase *tests;
 };
 
 struct TCase {
-    const char *name;
-    tcase_setup_function setup;
-    tcase_teardown_function teardown;
-    tcase_test_function *tests;
-    int ntests;
-    int allocated;
-    TCase *next_tcase;
+  const char *name;
+  tcase_setup_function setup;
+  tcase_teardown_function teardown;
+  tcase_test_function *tests;
+  int ntests;
+  int allocated;
+  TCase *next_tcase;
 };
 
-
 /* Internal helper. */
-void _check_set_test_info(char const *function,
-                          char const *filename, int lineno);
-
+void _check_set_test_info(char const *function, char const *filename,
+                          int lineno);
 
 /*
  * Prototypes for the actual implementation.
@@ -105,8 +106,7 @@ void _fail_unless(int condition, const char *file, int line, const char *msg);
 Suite *suite_create(const char *name);
 TCase *tcase_create(const char *name);
 void suite_add_tcase(Suite *suite, TCase *tc);
-void tcase_add_checked_fixture(TCase *,
-                               tcase_setup_function,
+void tcase_add_checked_fixture(TCase *, tcase_setup_function,
                                tcase_teardown_function);
 void tcase_add_test(TCase *tc, tcase_test_function test);
 SRunner *srunner_create(Suite *suite);
diff --git a/contrib/expat/tests/runtests.c b/contrib/expat/tests/runtests.c
index 4f4d2687f113..b7411e925900 100644
--- a/contrib/expat/tests/runtests.c
+++ b/contrib/expat/tests/runtests.c
@@ -31,103 +31,96 @@
 */
 
 #if defined(NDEBUG)
-# undef NDEBUG  /* because test suite relies on assert(...) at the moment */
+#  undef NDEBUG /* because test suite relies on assert(...) at the moment */
 #endif
 
 #ifdef HAVE_EXPAT_CONFIG_H
-# include <expat_config.h>
+#  include <expat_config.h>
 #endif
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <stddef.h>  /* ptrdiff_t */
+#include <stddef.h> /* ptrdiff_t */
 #include <ctype.h>
 #include <limits.h>
 
-
 #if defined(_WIN32) && defined(_MSC_VER) && (_MSC_VER < 1600)
-    /* For vs2003/7.1 up to vs2008/9.0; _MSC_VER 1600 is vs2010/10.0 */
- #if defined(_WIN64)
-    typedef __int64 intptr_t;
- #else
-    typedef __int32 intptr_t;
- #endif
-    typedef unsigned __int64 uint64_t;
+/* For vs2003/7.1 up to vs2008/9.0; _MSC_VER 1600 is vs2010/10.0 */
+#  if defined(_WIN64)
+typedef __int64 intptr_t;
+#  else
+typedef __int32 intptr_t;
+#  endif
+typedef unsigned __int64 uint64_t;
 #else
- #include <stdint.h> /* intptr_t uint64_t */
+#  include <stdint.h> /* intptr_t uint64_t */
 #endif
 
-
 #if ! defined(__cplusplus)
-# if defined(_MSC_VER) && (_MSC_VER <= 1700)
-   /* for vs2012/11.0/1700 and earlier Visual Studio compilers */
-#  define bool   int
-#  define false  0
-#  define true   1
-# else
-#  include <stdbool.h>
-# endif
+#  if defined(_MSC_VER) && (_MSC_VER <= 1700)
+/* for vs2012/11.0/1700 and earlier Visual Studio compilers */
+#    define bool int
+#    define false 0
+#    define true 1
+#  else
+#    include <stdbool.h>
+#  endif
 #endif
 
-
 #include "expat.h"
 #include "chardata.h"
 #include "structdata.h"
-#include "internal.h"  /* for UNUSED_P only */
+#include "internal.h" /* for UNUSED_P only */
 #include "minicheck.h"
 #include "memcheck.h"
 #include "siphash.h"
 #include "ascii.h" /* for ASCII_xxx */
 
 #ifdef XML_LARGE_SIZE
-# define XML_FMT_INT_MOD "ll"
+#  define XML_FMT_INT_MOD "ll"
 #else
-# define XML_FMT_INT_MOD "l"
+#  define XML_FMT_INT_MOD "l"
 #endif
 
 #ifdef XML_UNICODE_WCHAR_T
-# define XML_FMT_CHAR "lc"
-# define XML_FMT_STR "ls"
-# include <wchar.h>
-# define xcstrlen(s) wcslen(s)
-# define xcstrcmp(s, t) wcscmp((s), (t))
-# define xcstrncmp(s, t, n) wcsncmp((s), (t), (n))
-# define XCS(s) _XCS(s)
-# define _XCS(s) L ## s
+#  define XML_FMT_CHAR "lc"
+#  define XML_FMT_STR "ls"
+#  include <wchar.h>
+#  define xcstrlen(s) wcslen(s)
+#  define xcstrcmp(s, t) wcscmp((s), (t))
+#  define xcstrncmp(s, t, n) wcsncmp((s), (t), (n))
+#  define XCS(s) _XCS(s)
+#  define _XCS(s) L##s
 #else
-# ifdef XML_UNICODE
-#  error "No support for UTF-16 character without wchar_t in tests"
-# else
-#  define XML_FMT_CHAR "c"
-#  define XML_FMT_STR "s"
-#  define xcstrlen(s) strlen(s)
-#  define xcstrcmp(s, t) strcmp((s), (t))
-#  define xcstrncmp(s, t, n) strncmp((s), (t), (n))
-#  define XCS(s) s
-# endif /* XML_UNICODE */
-#endif /* XML_UNICODE_WCHAR_T */
-
-
-static XML_Parser parser = NULL;
-
+#  ifdef XML_UNICODE
+#    error "No support for UTF-16 character without wchar_t in tests"
+#  else
+#    define XML_FMT_CHAR "c"
+#    define XML_FMT_STR "s"
+#    define xcstrlen(s) strlen(s)
+#    define xcstrcmp(s, t) strcmp((s), (t))
+#    define xcstrncmp(s, t, n) strncmp((s), (t), (n))
+#    define XCS(s) s
+#  endif /* XML_UNICODE */
+#endif   /* XML_UNICODE_WCHAR_T */
+
+static XML_Parser g_parser = NULL;
 
 static void
-basic_setup(void)
-{
-    parser = XML_ParserCreate(NULL);
-    if (parser == NULL)
-        fail("Parser not created.");
+basic_setup(void) {
+  g_parser = XML_ParserCreate(NULL);
+  if (g_parser == NULL)
+    fail("Parser not created.");
 }
 
 static void
-basic_teardown(void)
-{
-    if (parser != NULL) {
-        XML_ParserFree(parser);
-        parser = NULL;
-    }
+basic_teardown(void) {
+  if (g_parser != NULL) {
+    XML_ParserFree(g_parser);
+    g_parser = NULL;
+  }
 }
 
 /* Generate a failure using the parser state to create an error message;
@@ -135,605 +128,597 @@ basic_teardown(void)
    expecting.
 */
 static void
-_xml_failure(XML_Parser parser, const char *file, int line)
-{
-    char buffer[1024];
-    enum XML_Error err = XML_GetErrorCode(parser);
-    sprintf(buffer,
-            "    %d: %" XML_FMT_STR " (line %"
-                XML_FMT_INT_MOD "u, offset %"
-                XML_FMT_INT_MOD "u)\n    reported from %s, line %d\n",
-            err,
-            XML_ErrorString(err),
-            XML_GetCurrentLineNumber(parser),
-            XML_GetCurrentColumnNumber(parser),
-            file, line);
-    _fail_unless(0, file, line, buffer);
+_xml_failure(XML_Parser parser, const char *file, int line) {
+  char buffer[1024];
+  enum XML_Error err = XML_GetErrorCode(parser);
+  sprintf(buffer,
+          "    %d: %" XML_FMT_STR " (line %" XML_FMT_INT_MOD
+          "u, offset %" XML_FMT_INT_MOD "u)\n    reported from %s, line %d\n",
+          err, XML_ErrorString(err), XML_GetCurrentLineNumber(parser),
+          XML_GetCurrentColumnNumber(parser), file, line);
+  _fail_unless(0, file, line, buffer);
 }
 
 static enum XML_Status
-_XML_Parse_SINGLE_BYTES(XML_Parser parser, const char *s, int len, int isFinal)
-{
-    enum XML_Status res = XML_STATUS_ERROR;
-    int offset = 0;
+_XML_Parse_SINGLE_BYTES(XML_Parser parser, const char *s, int len,
+                        int isFinal) {
+  enum XML_Status res = XML_STATUS_ERROR;
+  int offset = 0;
 
-    if (len == 0) {
-        return XML_Parse(parser, s, len, isFinal);
-    }
+  if (len == 0) {
+    return XML_Parse(parser, s, len, isFinal);
+  }
 
-    for (; offset < len; offset++) {
-        const int innerIsFinal = (offset == len - 1) && isFinal;
-        const char c = s[offset]; /* to help out-of-bounds detection */
-        res = XML_Parse(parser, &c, sizeof(char), innerIsFinal);
-        if (res != XML_STATUS_OK) {
-            return res;
-        }
+  for (; offset < len; offset++) {
+    const int innerIsFinal = (offset == len - 1) && isFinal;
+    const char c = s[offset]; /* to help out-of-bounds detection */
+    res = XML_Parse(parser, &c, sizeof(char), innerIsFinal);
+    if (res != XML_STATUS_OK) {
+      return res;
     }
-    return res;
+  }
+  return res;
 }
 
 #define xml_failure(parser) _xml_failure((parser), __FILE__, __LINE__)
 
 static void
-_expect_failure(const char *text, enum XML_Error errorCode, const char *errorMessage,
-                const char *file, int lineno)
-{
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_OK)
-        /* Hackish use of _fail_unless() macro, but let's us report
-           the right filename and line number. */
-        _fail_unless(0, file, lineno, errorMessage);
-    if (XML_GetErrorCode(parser) != errorCode)
-        _xml_failure(parser, file, lineno);
+_expect_failure(const char *text, enum XML_Error errorCode,
+                const char *errorMessage, const char *file, int lineno) {
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_OK)
+    /* Hackish use of _fail_unless() macro, but let's us report
+       the right filename and line number. */
+    _fail_unless(0, file, lineno, errorMessage);
+  if (XML_GetErrorCode(g_parser) != errorCode)
+    _xml_failure(g_parser, file, lineno);
 }
 
-#define expect_failure(text, errorCode, errorMessage) \
-        _expect_failure((text), (errorCode), (errorMessage), \
-                        __FILE__, __LINE__)
+#define expect_failure(text, errorCode, errorMessage)                          \
+  _expect_failure((text), (errorCode), (errorMessage), __FILE__, __LINE__)
 
 /* Dummy handlers for when we need to set a handler to tickle a bug,
    but it doesn't need to do anything.
 */
 static unsigned long dummy_handler_flags = 0;
 
-#define DUMMY_START_DOCTYPE_HANDLER_FLAG        (1UL << 0)
-#define DUMMY_END_DOCTYPE_HANDLER_FLAG          (1UL << 1)
-#define DUMMY_ENTITY_DECL_HANDLER_FLAG          (1UL << 2)
-#define DUMMY_NOTATION_DECL_HANDLER_FLAG        (1UL << 3)
-#define DUMMY_ELEMENT_DECL_HANDLER_FLAG         (1UL << 4)
-#define DUMMY_ATTLIST_DECL_HANDLER_FLAG         (1UL << 5)
-#define DUMMY_COMMENT_HANDLER_FLAG              (1UL << 6)
-#define DUMMY_PI_HANDLER_FLAG                   (1UL << 7)
-#define DUMMY_START_ELEMENT_HANDLER_FLAG        (1UL << 8)
-#define DUMMY_START_CDATA_HANDLER_FLAG          (1UL << 9)
-#define DUMMY_END_CDATA_HANDLER_FLAG            (1UL << 10)
+#define DUMMY_START_DOCTYPE_HANDLER_FLAG (1UL << 0)
+#define DUMMY_END_DOCTYPE_HANDLER_FLAG (1UL << 1)
+#define DUMMY_ENTITY_DECL_HANDLER_FLAG (1UL << 2)
+#define DUMMY_NOTATION_DECL_HANDLER_FLAG (1UL << 3)
+#define DUMMY_ELEMENT_DECL_HANDLER_FLAG (1UL << 4)
+#define DUMMY_ATTLIST_DECL_HANDLER_FLAG (1UL << 5)
+#define DUMMY_COMMENT_HANDLER_FLAG (1UL << 6)
+#define DUMMY_PI_HANDLER_FLAG (1UL << 7)
+#define DUMMY_START_ELEMENT_HANDLER_FLAG (1UL << 8)
+#define DUMMY_START_CDATA_HANDLER_FLAG (1UL << 9)
+#define DUMMY_END_CDATA_HANDLER_FLAG (1UL << 10)
 #define DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG (1UL << 11)
-#define DUMMY_START_NS_DECL_HANDLER_FLAG        (1UL << 12)
-#define DUMMY_END_NS_DECL_HANDLER_FLAG          (1UL << 13)
-#define DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG   (1UL << 14)
-#define DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG     (1UL << 15)
-#define DUMMY_SKIP_HANDLER_FLAG                 (1UL << 16)
-#define DUMMY_DEFAULT_HANDLER_FLAG              (1UL << 17)
-
+#define DUMMY_START_NS_DECL_HANDLER_FLAG (1UL << 12)
+#define DUMMY_END_NS_DECL_HANDLER_FLAG (1UL << 13)
+#define DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG (1UL << 14)
+#define DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG (1UL << 15)
+#define DUMMY_SKIP_HANDLER_FLAG (1UL << 16)
+#define DUMMY_DEFAULT_HANDLER_FLAG (1UL << 17)
 
 static void XMLCALL
-dummy_xdecl_handler(void *UNUSED_P(userData),
-                    const XML_Char *UNUSED_P(version),
-                    const XML_Char *UNUSED_P(encoding),
-                    int UNUSED_P(standalone))
-{}
+dummy_xdecl_handler(void *userData, const XML_Char *version,
+                    const XML_Char *encoding, int standalone) {
+  UNUSED_P(userData);
+  UNUSED_P(version);
+  UNUSED_P(encoding);
+  UNUSED_P(standalone);
+}
 
 static void XMLCALL
-dummy_start_doctype_handler(void           *UNUSED_P(userData),
-                            const XML_Char *UNUSED_P(doctypeName),
-                            const XML_Char *UNUSED_P(sysid),
-                            const XML_Char *UNUSED_P(pubid),
-                            int            UNUSED_P(has_internal_subset))
-{
-    dummy_handler_flags |= DUMMY_START_DOCTYPE_HANDLER_FLAG;
+dummy_start_doctype_handler(void *userData, const XML_Char *doctypeName,
+                            const XML_Char *sysid, const XML_Char *pubid,
+                            int has_internal_subset) {
+  UNUSED_P(userData);
+  UNUSED_P(doctypeName);
+  UNUSED_P(sysid);
+  UNUSED_P(pubid);
+  UNUSED_P(has_internal_subset);
+  dummy_handler_flags |= DUMMY_START_DOCTYPE_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_end_doctype_handler(void *UNUSED_P(userData))
-{
-    dummy_handler_flags |= DUMMY_END_DOCTYPE_HANDLER_FLAG;
+dummy_end_doctype_handler(void *userData) {
+  UNUSED_P(userData);
+  dummy_handler_flags |= DUMMY_END_DOCTYPE_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_entity_decl_handler(void           *UNUSED_P(userData),
-                          const XML_Char *UNUSED_P(entityName),
-                          int            UNUSED_P(is_parameter_entity),
-                          const XML_Char *UNUSED_P(value),
-                          int            UNUSED_P(value_length),
-                          const XML_Char *UNUSED_P(base),
-                          const XML_Char *UNUSED_P(systemId),
-                          const XML_Char *UNUSED_P(publicId),
-                          const XML_Char *UNUSED_P(notationName))
-{
-    dummy_handler_flags |= DUMMY_ENTITY_DECL_HANDLER_FLAG;
+dummy_entity_decl_handler(void *userData, const XML_Char *entityName,
+                          int is_parameter_entity, const XML_Char *value,
+                          int value_length, const XML_Char *base,
+                          const XML_Char *systemId, const XML_Char *publicId,
+                          const XML_Char *notationName) {
+  UNUSED_P(userData);
+  UNUSED_P(entityName);
+  UNUSED_P(is_parameter_entity);
+  UNUSED_P(value);
+  UNUSED_P(value_length);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  UNUSED_P(notationName);
+  dummy_handler_flags |= DUMMY_ENTITY_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_notation_decl_handler(void *UNUSED_P(userData),
-                            const XML_Char *UNUSED_P(notationName),
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    dummy_handler_flags |= DUMMY_NOTATION_DECL_HANDLER_FLAG;
+dummy_notation_decl_handler(void *userData, const XML_Char *notationName,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  UNUSED_P(userData);
+  UNUSED_P(notationName);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  dummy_handler_flags |= DUMMY_NOTATION_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_element_decl_handler(void *UNUSED_P(userData),
-                           const XML_Char *UNUSED_P(name),
-                           XML_Content *model)
-{
-    /* The content model must be freed by the handler.  Unfortunately
-     * we cannot pass the parser as the userData because this is used
-     * with other handlers that require other userData.
-     */
-    XML_FreeContentModel(parser, model);
-    dummy_handler_flags |= DUMMY_ELEMENT_DECL_HANDLER_FLAG;
+dummy_element_decl_handler(void *userData, const XML_Char *name,
+                           XML_Content *model) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  /* The content model must be freed by the handler.  Unfortunately
+   * we cannot pass the parser as the userData because this is used
+   * with other handlers that require other userData.
+   */
+  XML_FreeContentModel(g_parser, model);
+  dummy_handler_flags |= DUMMY_ELEMENT_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_attlist_decl_handler(void           *UNUSED_P(userData),
-                           const XML_Char *UNUSED_P(elname),
-                           const XML_Char *UNUSED_P(attname),
-                           const XML_Char *UNUSED_P(att_type),
-                           const XML_Char *UNUSED_P(dflt),
-                           int            UNUSED_P(isrequired))
-{
-    dummy_handler_flags |= DUMMY_ATTLIST_DECL_HANDLER_FLAG;
+dummy_attlist_decl_handler(void *userData, const XML_Char *elname,
+                           const XML_Char *attname, const XML_Char *att_type,
+                           const XML_Char *dflt, int isrequired) {
+  UNUSED_P(userData);
+  UNUSED_P(elname);
+  UNUSED_P(attname);
+  UNUSED_P(att_type);
+  UNUSED_P(dflt);
+  UNUSED_P(isrequired);
+  dummy_handler_flags |= DUMMY_ATTLIST_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_comment_handler(void *UNUSED_P(userData), const XML_Char *UNUSED_P(data))
-{
-    dummy_handler_flags |= DUMMY_COMMENT_HANDLER_FLAG;
+dummy_comment_handler(void *userData, const XML_Char *data) {
+  UNUSED_P(userData);
+  UNUSED_P(data);
+  dummy_handler_flags |= DUMMY_COMMENT_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_pi_handler(void *UNUSED_P(userData), const XML_Char *UNUSED_P(target), const XML_Char *UNUSED_P(data))
-{
-    dummy_handler_flags |= DUMMY_PI_HANDLER_FLAG;
+dummy_pi_handler(void *userData, const XML_Char *target, const XML_Char *data) {
+  UNUSED_P(userData);
+  UNUSED_P(target);
+  UNUSED_P(data);
+  dummy_handler_flags |= DUMMY_PI_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_start_element(void *UNUSED_P(userData),
-                    const XML_Char *UNUSED_P(name), const XML_Char **UNUSED_P(atts))
-{
-    dummy_handler_flags |= DUMMY_START_ELEMENT_HANDLER_FLAG;
+dummy_start_element(void *userData, const XML_Char *name,
+                    const XML_Char **atts) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  UNUSED_P(atts);
+  dummy_handler_flags |= DUMMY_START_ELEMENT_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_end_element(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name))
-{}
+dummy_end_element(void *userData, const XML_Char *name) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+}
 
 static void XMLCALL
-dummy_start_cdata_handler(void *UNUSED_P(userData))
-{
-    dummy_handler_flags |= DUMMY_START_CDATA_HANDLER_FLAG;
+dummy_start_cdata_handler(void *userData) {
+  UNUSED_P(userData);
+  dummy_handler_flags |= DUMMY_START_CDATA_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_end_cdata_handler(void *UNUSED_P(userData))
-{
-    dummy_handler_flags |= DUMMY_END_CDATA_HANDLER_FLAG;
+dummy_end_cdata_handler(void *userData) {
+  UNUSED_P(userData);
+  dummy_handler_flags |= DUMMY_END_CDATA_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_cdata_handler(void *UNUSED_P(userData),
-                    const XML_Char *UNUSED_P(s),
-                    int UNUSED_P(len))
-{}
+dummy_cdata_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(userData);
+  UNUSED_P(s);
+  UNUSED_P(len);
+}
 
 static void XMLCALL
-dummy_start_namespace_decl_handler(void *UNUSED_P(userData),
-                                   const XML_Char *UNUSED_P(prefix),
-                                   const XML_Char *UNUSED_P(uri))
-{
-    dummy_handler_flags |= DUMMY_START_NS_DECL_HANDLER_FLAG;
+dummy_start_namespace_decl_handler(void *userData, const XML_Char *prefix,
+                                   const XML_Char *uri) {
+  UNUSED_P(userData);
+  UNUSED_P(prefix);
+  UNUSED_P(uri);
+  dummy_handler_flags |= DUMMY_START_NS_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_end_namespace_decl_handler(void *UNUSED_P(userData),
-                                 const XML_Char *UNUSED_P(prefix))
-{
-    dummy_handler_flags |= DUMMY_END_NS_DECL_HANDLER_FLAG;
+dummy_end_namespace_decl_handler(void *userData, const XML_Char *prefix) {
+  UNUSED_P(userData);
+  UNUSED_P(prefix);
+  dummy_handler_flags |= DUMMY_END_NS_DECL_HANDLER_FLAG;
 }
 
 /* This handler is obsolete, but while the code exists we should
  * ensure that dealing with the handler is covered by tests.
  */
 static void XMLCALL
-dummy_unparsed_entity_decl_handler(void *UNUSED_P(userData),
-                                   const XML_Char *UNUSED_P(entityName),
-                                   const XML_Char *UNUSED_P(base),
-                                   const XML_Char *UNUSED_P(systemId),
-                                   const XML_Char *UNUSED_P(publicId),
-                                   const XML_Char *UNUSED_P(notationName))
-{
-    dummy_handler_flags |= DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG;
+dummy_unparsed_entity_decl_handler(void *userData, const XML_Char *entityName,
+                                   const XML_Char *base,
+                                   const XML_Char *systemId,
+                                   const XML_Char *publicId,
+                                   const XML_Char *notationName) {
+  UNUSED_P(userData);
+  UNUSED_P(entityName);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  UNUSED_P(notationName);
+  dummy_handler_flags |= DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_default_handler(void *UNUSED_P(userData),
-                      const XML_Char *UNUSED_P(s),
-                      int UNUSED_P(len))
-{}
+dummy_default_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(userData);
+  UNUSED_P(s);
+  UNUSED_P(len);
+}
 
 static void XMLCALL
-dummy_start_doctype_decl_handler(void *UNUSED_P(userData),
-                                 const XML_Char *UNUSED_P(doctypeName),
-                                 const XML_Char *UNUSED_P(sysid),
-                                 const XML_Char *UNUSED_P(pubid),
-                                 int UNUSED_P(has_internal_subset))
-{
-    dummy_handler_flags |= DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG;
+dummy_start_doctype_decl_handler(void *userData, const XML_Char *doctypeName,
+                                 const XML_Char *sysid, const XML_Char *pubid,
+                                 int has_internal_subset) {
+  UNUSED_P(userData);
+  UNUSED_P(doctypeName);
+  UNUSED_P(sysid);
+  UNUSED_P(pubid);
+  UNUSED_P(has_internal_subset);
+  dummy_handler_flags |= DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_end_doctype_decl_handler(void *UNUSED_P(userData))
-{
-    dummy_handler_flags |= DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG;
+dummy_end_doctype_decl_handler(void *userData) {
+  UNUSED_P(userData);
+  dummy_handler_flags |= DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG;
 }
 
 static void XMLCALL
-dummy_skip_handler(void *UNUSED_P(userData),
-                   const XML_Char *UNUSED_P(entityName),
-                   int UNUSED_P(is_parameter_entity))
-{
-    dummy_handler_flags |= DUMMY_SKIP_HANDLER_FLAG;
+dummy_skip_handler(void *userData, const XML_Char *entityName,
+                   int is_parameter_entity) {
+  UNUSED_P(userData);
+  UNUSED_P(entityName);
+  UNUSED_P(is_parameter_entity);
+  dummy_handler_flags |= DUMMY_SKIP_HANDLER_FLAG;
 }
 
 /* Useful external entity handler */
 typedef struct ExtOption {
-    const XML_Char *system_id;
-    const char *parse_text;
+  const XML_Char *system_id;
+  const char *parse_text;
 } ExtOption;
 
 static int XMLCALL
-external_entity_optioner(XML_Parser parser,
-                         const XML_Char *context,
-                         const XML_Char *UNUSED_P(base),
-                         const XML_Char *systemId,
-                         const XML_Char *UNUSED_P(publicId))
-{
-    ExtOption *options = (ExtOption *)XML_GetUserData(parser);
-    XML_Parser ext_parser;
-
-    while (options->parse_text != NULL) {
-        if (!xcstrcmp(systemId, options->system_id)) {
-            enum XML_Status rc;
-            ext_parser =
-                XML_ExternalEntityParserCreate(parser, context, NULL);
-            if (ext_parser == NULL)
-                return XML_STATUS_ERROR;
-            rc = _XML_Parse_SINGLE_BYTES(ext_parser, options->parse_text,
-                                         (int)strlen(options->parse_text),
-                                         XML_TRUE);
-            XML_ParserFree(ext_parser);
-            return rc;
-        }
-        options++;
+external_entity_optioner(XML_Parser parser, const XML_Char *context,
+                         const XML_Char *base, const XML_Char *systemId,
+                         const XML_Char *publicId) {
+  ExtOption *options = (ExtOption *)XML_GetUserData(parser);
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  while (options->parse_text != NULL) {
+    if (! xcstrcmp(systemId, options->system_id)) {
+      enum XML_Status rc;
+      ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+      if (ext_parser == NULL)
+        return XML_STATUS_ERROR;
+      rc = _XML_Parse_SINGLE_BYTES(ext_parser, options->parse_text,
+                                   (int)strlen(options->parse_text), XML_TRUE);
+      XML_ParserFree(ext_parser);
+      return rc;
     }
-    fail("No suitable option found");
-    return XML_STATUS_ERROR;
+    options++;
+  }
+  fail("No suitable option found");
+  return XML_STATUS_ERROR;
 }
 
 /*
  * Parameter entity evaluation support.
  */
-#define ENTITY_MATCH_FAIL      (-1)
-#define ENTITY_MATCH_NOT_FOUND  (0)
-#define ENTITY_MATCH_SUCCESS    (1)
+#define ENTITY_MATCH_FAIL (-1)
+#define ENTITY_MATCH_NOT_FOUND (0)
+#define ENTITY_MATCH_SUCCESS (1)
 static const XML_Char *entity_name_to_match = NULL;
 static const XML_Char *entity_value_to_match = NULL;
 static int entity_match_flag = ENTITY_MATCH_NOT_FOUND;
 
 static void XMLCALL
-param_entity_match_handler(void           *UNUSED_P(userData),
-                           const XML_Char *entityName,
-                           int            is_parameter_entity,
-                           const XML_Char *value,
-                           int            value_length,
-                           const XML_Char *UNUSED_P(base),
-                           const XML_Char *UNUSED_P(systemId),
-                           const XML_Char *UNUSED_P(publicId),
-                           const XML_Char *UNUSED_P(notationName))
-{
-    if (!is_parameter_entity ||
-        entity_name_to_match == NULL ||
-        entity_value_to_match == NULL) {
-        return;
-    }
-    if (!xcstrcmp(entityName, entity_name_to_match)) {
-        /* The cast here is safe because we control the horizontal and
-         * the vertical, and we therefore know our strings are never
-         * going to overflow an int.
-         */
-        if (value_length != (int)xcstrlen(entity_value_to_match) ||
-            xcstrncmp(value, entity_value_to_match, value_length)) {
-            entity_match_flag = ENTITY_MATCH_FAIL;
-        } else {
-            entity_match_flag = ENTITY_MATCH_SUCCESS;
-        }
+param_entity_match_handler(void *userData, const XML_Char *entityName,
+                           int is_parameter_entity, const XML_Char *value,
+                           int value_length, const XML_Char *base,
+                           const XML_Char *systemId, const XML_Char *publicId,
+                           const XML_Char *notationName) {
+  UNUSED_P(userData);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  UNUSED_P(notationName);
+  if (! is_parameter_entity || entity_name_to_match == NULL
+      || entity_value_to_match == NULL) {
+    return;
+  }
+  if (! xcstrcmp(entityName, entity_name_to_match)) {
+    /* The cast here is safe because we control the horizontal and
+     * the vertical, and we therefore know our strings are never
+     * going to overflow an int.
+     */
+    if (value_length != (int)xcstrlen(entity_value_to_match)
+        || xcstrncmp(value, entity_value_to_match, value_length)) {
+      entity_match_flag = ENTITY_MATCH_FAIL;
+    } else {
+      entity_match_flag = ENTITY_MATCH_SUCCESS;
     }
-    /* Else leave the match flag alone */
+  }
+  /* Else leave the match flag alone */
 }
 
 /*
  * Character & encoding tests.
  */
 
-START_TEST(test_nul_byte)
-{
-    char text[] = "<doc>\0</doc>";
+START_TEST(test_nul_byte) {
+  char text[] = "<doc>\0</doc>";
 
-    /* test that a NUL byte (in US-ASCII data) is an error */
-    if (_XML_Parse_SINGLE_BYTES(parser, text, sizeof(text) - 1, XML_TRUE) == XML_STATUS_OK)
-        fail("Parser did not report error on NUL-byte.");
-    if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
-        xml_failure(parser);
+  /* test that a NUL byte (in US-ASCII data) is an error */
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Parser did not report error on NUL-byte.");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
-START_TEST(test_u0000_char)
-{
-    /* test that a NUL byte (in US-ASCII data) is an error */
-    expect_failure("<doc>&#0;</doc>",
-                   XML_ERROR_BAD_CHAR_REF,
-                   "Parser did not report error on NUL-byte.");
+START_TEST(test_u0000_char) {
+  /* test that a NUL byte (in US-ASCII data) is an error */
+  expect_failure("<doc>&#0;</doc>", XML_ERROR_BAD_CHAR_REF,
+                 "Parser did not report error on NUL-byte.");
 }
 END_TEST
 
-START_TEST(test_siphash_self)
-{
-    if (! sip24_valid())
-        fail("SipHash self-test failed");
+START_TEST(test_siphash_self) {
+  if (! sip24_valid())
+    fail("SipHash self-test failed");
 }
 END_TEST
 
-START_TEST(test_siphash_spec)
-{
-    /* https://131002.net/siphash/siphash.pdf (page 19, "Test values") */
-    const char message[] = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
-            "\x0a\x0b\x0c\x0d\x0e";
-    const size_t len = sizeof(message) - 1;
-    const uint64_t expected = _SIP_ULL(0xa129ca61U, 0x49be45e5U);
-    struct siphash state;
-    struct sipkey key;
+START_TEST(test_siphash_spec) {
+  /* https://131002.net/siphash/siphash.pdf (page 19, "Test values") */
+  const char message[] = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
+                         "\x0a\x0b\x0c\x0d\x0e";
+  const size_t len = sizeof(message) - 1;
+  const uint64_t expected = _SIP_ULL(0xa129ca61U, 0x49be45e5U);
+  struct siphash state;
+  struct sipkey key;
 
-    sip_tokey(&key,
-            "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
-            "\x0a\x0b\x0c\x0d\x0e\x0f");
-    sip24_init(&state, &key);
+  sip_tokey(&key, "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09"
+                  "\x0a\x0b\x0c\x0d\x0e\x0f");
+  sip24_init(&state, &key);
 
-    /* Cover spread across calls */
-    sip24_update(&state, message, 4);
-    sip24_update(&state, message + 4, len - 4);
+  /* Cover spread across calls */
+  sip24_update(&state, message, 4);
+  sip24_update(&state, message + 4, len - 4);
 
-    /* Cover null length */
-    sip24_update(&state, message, 0);
+  /* Cover null length */
+  sip24_update(&state, message, 0);
 
-    if (sip24_final(&state) != expected)
-        fail("sip24_final failed spec test\n");
+  if (sip24_final(&state) != expected)
+    fail("sip24_final failed spec test\n");
 
-    /* Cover wrapper */
-    if (siphash24(message, len, &key) != expected)
-        fail("siphash24 failed spec test\n");
+  /* Cover wrapper */
+  if (siphash24(message, len, &key) != expected)
+    fail("siphash24 failed spec test\n");
 }
 END_TEST
 
-START_TEST(test_bom_utf8)
-{
-    /* This test is really just making sure we don't core on a UTF-8 BOM. */
-    const char *text = "\357\273\277<e/>";
+START_TEST(test_bom_utf8) {
+  /* This test is really just making sure we don't core on a UTF-8 BOM. */
+  const char *text = "\357\273\277<e/>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_bom_utf16_be)
-{
-    char text[] = "\376\377\0<\0e\0/\0>";
+START_TEST(test_bom_utf16_be) {
+  char text[] = "\376\377\0<\0e\0/\0>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_bom_utf16_le)
-{
-    char text[] = "\377\376<\0e\0/\0>\0";
+START_TEST(test_bom_utf16_le) {
+  char text[] = "\377\376<\0e\0/\0>\0";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Parse whole buffer at once to exercise a different code path */
-START_TEST(test_nobom_utf16_le)
-{
-    char text[] = " \0<\0e\0/\0>\0";
+START_TEST(test_nobom_utf16_le) {
+  char text[] = " \0<\0e\0/\0>\0";
 
-    if (XML_Parse(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (XML_Parse(g_parser, text, sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 static void XMLCALL
-accumulate_characters(void *userData, const XML_Char *s, int len)
-{
-    CharData_AppendXMLChars((CharData *)userData, s, len);
+accumulate_characters(void *userData, const XML_Char *s, int len) {
+  CharData_AppendXMLChars((CharData *)userData, s, len);
 }
 
 static void XMLCALL
-accumulate_attribute(void *userData, const XML_Char *UNUSED_P(name),
-                     const XML_Char **atts)
-{
-    CharData *storage = (CharData *)userData;
-
-    /* Check there are attributes to deal with */
-    if (atts == NULL)
-        return;
-
-    while (storage->count < 0 && atts[0] != NULL) {
-        /* "accumulate" the value of the first attribute we see */
-        CharData_AppendXMLChars(storage, atts[1], -1);
-        atts += 2;
-    }
-}
+accumulate_attribute(void *userData, const XML_Char *name,
+                     const XML_Char **atts) {
+  CharData *storage = (CharData *)userData;
+  UNUSED_P(name);
+  /* Check there are attributes to deal with */
+  if (atts == NULL)
+    return;
 
+  while (storage->count < 0 && atts[0] != NULL) {
+    /* "accumulate" the value of the first attribute we see */
+    CharData_AppendXMLChars(storage, atts[1], -1);
+    atts += 2;
+  }
+}
 
 static void
 _run_character_check(const char *text, const XML_Char *expected,
-                     const char *file, int line)
-{
-    CharData storage;
+                     const char *file, int line) {
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        _xml_failure(parser, file, line);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    _xml_failure(g_parser, file, line);
+  CharData_CheckXMLChars(&storage, expected);
 }
 
-#define run_character_check(text, expected) \
-        _run_character_check(text, expected, __FILE__, __LINE__)
+#define run_character_check(text, expected)                                    \
+  _run_character_check(text, expected, __FILE__, __LINE__)
 
 static void
 _run_attribute_check(const char *text, const XML_Char *expected,
-                     const char *file, int line)
-{
-    CharData storage;
+                     const char *file, int line) {
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        _xml_failure(parser, file, line);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    _xml_failure(g_parser, file, line);
+  CharData_CheckXMLChars(&storage, expected);
 }
 
-#define run_attribute_check(text, expected) \
-        _run_attribute_check(text, expected, __FILE__, __LINE__)
+#define run_attribute_check(text, expected)                                    \
+  _run_attribute_check(text, expected, __FILE__, __LINE__)
 
 typedef struct ExtTest {
-    const char *parse_text;
-    const XML_Char *encoding;
-    CharData *storage;
+  const char *parse_text;
+  const XML_Char *encoding;
+  CharData *storage;
 } ExtTest;
 
 static void XMLCALL
-ext_accumulate_characters(void *userData, const XML_Char *s, int len)
-{
-    ExtTest *test_data = (ExtTest *)userData;
-    accumulate_characters(test_data->storage, s, len);
+ext_accumulate_characters(void *userData, const XML_Char *s, int len) {
+  ExtTest *test_data = (ExtTest *)userData;
+  accumulate_characters(test_data->storage, s, len);
 }
 
 static void
-_run_ext_character_check(const char *text,
-                         ExtTest *test_data,
-                         const XML_Char *expected,
-                         const char *file, int line)
-{
-    CharData storage;
+_run_ext_character_check(const char *text, ExtTest *test_data,
+                         const XML_Char *expected, const char *file, int line) {
+  CharData *const storage = (CharData *)malloc(sizeof(CharData));
 
-    CharData_Init(&storage);
-    test_data->storage = &storage;
-    XML_SetUserData(parser, test_data);
-    XML_SetCharacterDataHandler(parser, ext_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        _xml_failure(parser, file, line);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(storage);
+  test_data->storage = storage;
+  XML_SetUserData(g_parser, test_data);
+  XML_SetCharacterDataHandler(g_parser, ext_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    _xml_failure(g_parser, file, line);
+  CharData_CheckXMLChars(storage, expected);
+
+  free(storage);
 }
 
-#define run_ext_character_check(text, test_data, expected)               \
-    _run_ext_character_check(text, test_data, expected, __FILE__, __LINE__)
+#define run_ext_character_check(text, test_data, expected)                     \
+  _run_ext_character_check(text, test_data, expected, __FILE__, __LINE__)
 
 /* Regression test for SF bug #491986. */
-START_TEST(test_danish_latin1)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
-        "<e>J\xF8rgen \xE6\xF8\xE5\xC6\xD8\xC5</e>";
+START_TEST(test_danish_latin1) {
+  const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+                     "<e>J\xF8rgen \xE6\xF8\xE5\xC6\xD8\xC5</e>";
 #ifdef XML_UNICODE
-    const XML_Char *expected =
-        XCS("J\x00f8rgen \x00e6\x00f8\x00e5\x00c6\x00d8\x00c5");
+  const XML_Char *expected
+      = XCS("J\x00f8rgen \x00e6\x00f8\x00e5\x00c6\x00d8\x00c5");
 #else
-    const XML_Char *expected =
-        XCS("J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
+  const XML_Char *expected
+      = XCS("J\xC3\xB8rgen \xC3\xA6\xC3\xB8\xC3\xA5\xC3\x86\xC3\x98\xC3\x85");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
-
 /* Regression test for SF bug #514281. */
-START_TEST(test_french_charref_hexidecimal)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
-        "<doc>&#xE9;&#xE8;&#xE0;&#xE7;&#xEA;&#xC8;</doc>";
+START_TEST(test_french_charref_hexidecimal) {
+  const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+                     "<doc>&#xE9;&#xE8;&#xE0;&#xE7;&#xEA;&#xC8;</doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected =
-        XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+  const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
 #else
-    const XML_Char *expected =
-        XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+  const XML_Char *expected
+      = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
-START_TEST(test_french_charref_decimal)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
-        "<doc>&#233;&#232;&#224;&#231;&#234;&#200;</doc>";
+START_TEST(test_french_charref_decimal) {
+  const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+                     "<doc>&#233;&#232;&#224;&#231;&#234;&#200;</doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected =
-        XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+  const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
 #else
-    const XML_Char *expected =
-        XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+  const XML_Char *expected
+      = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
-START_TEST(test_french_latin1)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
-        "<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
+START_TEST(test_french_latin1) {
+  const char *text = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+                     "<doc>\xE9\xE8\xE0\xE7\xEa\xC8</doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected =
-        XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
+  const XML_Char *expected = XCS("\x00e9\x00e8\x00e0\x00e7\x00ea\x00c8");
 #else
-    const XML_Char *expected =
-        XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
+  const XML_Char *expected
+      = XCS("\xC3\xA9\xC3\xA8\xC3\xA0\xC3\xA7\xC3\xAA\xC3\x88");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
-START_TEST(test_french_utf8)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<doc>\xC3\xA9</doc>";
+START_TEST(test_french_utf8) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<doc>\xC3\xA9</doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e9");
+  const XML_Char *expected = XCS("\x00e9");
 #else
-    const XML_Char *expected = XCS("\xC3\xA9");
+  const XML_Char *expected = XCS("\xC3\xA9");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
@@ -742,15 +727,14 @@ END_TEST
    characters as PCDATA and attribute value content, and XML Name
    characters as part of element and attribute names.
 */
-START_TEST(test_utf8_false_rejection)
-{
-    const char *text = "<doc>\xEF\xBA\xBF</doc>";
+START_TEST(test_utf8_false_rejection) {
+  const char *text = "<doc>\xEF\xBA\xBF</doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\xfebf");
+  const XML_Char *expected = XCS("\xfebf");
 #else
-    const XML_Char *expected = XCS("\xEF\xBA\xBF");
+  const XML_Char *expected = XCS("\xEF\xBA\xBF");
 #endif
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
@@ -759,100 +743,94 @@ END_TEST
    character will not be mistakenly interpreted as a valid UTF-8
    sequence.
 */
-START_TEST(test_illegal_utf8)
-{
-    char text[100];
-    int i;
+START_TEST(test_illegal_utf8) {
+  char text[100];
+  int i;
 
-    for (i = 128; i <= 255; ++i) {
-        sprintf(text, "<e>%ccd</e>", i);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_OK) {
-            sprintf(text,
-                    "expected token error for '%c' (ordinal %d) in UTF-8 text",
-                    i, i);
-            fail(text);
-        }
-        else if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
-            xml_failure(parser);
-        /* Reset the parser since we use the same parser repeatedly. */
-        XML_ParserReset(parser, NULL);
-    }
+  for (i = 128; i <= 255; ++i) {
+    sprintf(text, "<e>%ccd</e>", i);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        == XML_STATUS_OK) {
+      sprintf(text, "expected token error for '%c' (ordinal %d) in UTF-8 text",
+              i, i);
+      fail(text);
+    } else if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
+      xml_failure(g_parser);
+    /* Reset the parser since we use the same parser repeatedly. */
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
-
 /* Examples, not masks: */
-#define UTF8_LEAD_1  "\x7f"  /* 0b01111111 */
-#define UTF8_LEAD_2  "\xdf"  /* 0b11011111 */
-#define UTF8_LEAD_3  "\xef"  /* 0b11101111 */
-#define UTF8_LEAD_4  "\xf7"  /* 0b11110111 */
-#define UTF8_FOLLOW  "\xbf"  /* 0b10111111 */
-
-START_TEST(test_utf8_auto_align)
-{
-    struct TestCase {
-        ptrdiff_t expectedMovementInChars;
-        const char * input;
-    };
-
-    struct TestCase cases[] = {
-        {00, ""},
-
-        {00, UTF8_LEAD_1},
-
-        {-1, UTF8_LEAD_2},
-        {00, UTF8_LEAD_2 UTF8_FOLLOW},
-
-        {-1, UTF8_LEAD_3},
-        {-2, UTF8_LEAD_3 UTF8_FOLLOW},
-        {00, UTF8_LEAD_3 UTF8_FOLLOW UTF8_FOLLOW},
-
-        {-1, UTF8_LEAD_4},
-        {-2, UTF8_LEAD_4 UTF8_FOLLOW},
-        {-3, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW},
-        {00, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW UTF8_FOLLOW},
-    };
-
-    size_t i = 0;
-    bool success = true;
-    for (; i < sizeof(cases) / sizeof(*cases); i++) {
-        const char * fromLim = cases[i].input + strlen(cases[i].input);
-        const char * const fromLimInitially = fromLim;
-        ptrdiff_t actualMovementInChars;
-
-        _INTERNAL_trim_to_complete_utf8_characters(cases[i].input, &fromLim);
-
-        actualMovementInChars = (fromLim - fromLimInitially);
-        if (actualMovementInChars != cases[i].expectedMovementInChars) {
-            size_t j = 0;
-            success = false;
-            printf("[-] UTF-8 case %2u: Expected movement by %2d chars"
-                    ", actually moved by %2d chars: \"",
-                    (unsigned)(i + 1),
-                    (int)cases[i].expectedMovementInChars,
-                    (int)actualMovementInChars);
-            for (; j < strlen(cases[i].input); j++) {
-                printf("\\x%02x", (unsigned char)cases[i].input[j]);
-            }
-            printf("\"\n");
-        }
-    }
-
-    if (! success) {
-        fail("UTF-8 auto-alignment is not bullet-proof\n");
-    }
-}
-END_TEST
-
-START_TEST(test_utf16)
-{
-    /* <?xml version="1.0" encoding="UTF-16"?>
-     *  <doc a='123'>some {A} text</doc>
-     *
-     * where {A} is U+FF21, FULLWIDTH LATIN CAPITAL LETTER A
-     */
-    char text[] =
-        "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
+#define UTF8_LEAD_1 "\x7f" /* 0b01111111 */
+#define UTF8_LEAD_2 "\xdf" /* 0b11011111 */
+#define UTF8_LEAD_3 "\xef" /* 0b11101111 */
+#define UTF8_LEAD_4 "\xf7" /* 0b11110111 */
+#define UTF8_FOLLOW "\xbf" /* 0b10111111 */
+
+START_TEST(test_utf8_auto_align) {
+  struct TestCase {
+    ptrdiff_t expectedMovementInChars;
+    const char *input;
+  };
+
+  struct TestCase cases[] = {
+      {00, ""},
+
+      {00, UTF8_LEAD_1},
+
+      {-1, UTF8_LEAD_2},
+      {00, UTF8_LEAD_2 UTF8_FOLLOW},
+
+      {-1, UTF8_LEAD_3},
+      {-2, UTF8_LEAD_3 UTF8_FOLLOW},
+      {00, UTF8_LEAD_3 UTF8_FOLLOW UTF8_FOLLOW},
+
+      {-1, UTF8_LEAD_4},
+      {-2, UTF8_LEAD_4 UTF8_FOLLOW},
+      {-3, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW},
+      {00, UTF8_LEAD_4 UTF8_FOLLOW UTF8_FOLLOW UTF8_FOLLOW},
+  };
+
+  size_t i = 0;
+  bool success = true;
+  for (; i < sizeof(cases) / sizeof(*cases); i++) {
+    const char *fromLim = cases[i].input + strlen(cases[i].input);
+    const char *const fromLimInitially = fromLim;
+    ptrdiff_t actualMovementInChars;
+
+    _INTERNAL_trim_to_complete_utf8_characters(cases[i].input, &fromLim);
+
+    actualMovementInChars = (fromLim - fromLimInitially);
+    if (actualMovementInChars != cases[i].expectedMovementInChars) {
+      size_t j = 0;
+      success = false;
+      printf("[-] UTF-8 case %2u: Expected movement by %2d chars"
+             ", actually moved by %2d chars: \"",
+             (unsigned)(i + 1), (int)cases[i].expectedMovementInChars,
+             (int)actualMovementInChars);
+      for (; j < strlen(cases[i].input); j++) {
+        printf("\\x%02x", (unsigned char)cases[i].input[j]);
+      }
+      printf("\"\n");
+    }
+  }
+
+  if (! success) {
+    fail("UTF-8 auto-alignment is not bullet-proof\n");
+  }
+}
+END_TEST
+
+START_TEST(test_utf16) {
+  /* <?xml version="1.0" encoding="UTF-16"?>
+   *  <doc a='123'>some {A} text</doc>
+   *
+   * where {A} is U+FF21, FULLWIDTH LATIN CAPITAL LETTER A
+   */
+  char text[]
+      = "\000<\000?\000x\000m\000\154\000 \000v\000e\000r\000s\000i\000o"
         "\000n\000=\000'\0001\000.\000\060\000'\000 \000e\000n\000c\000o"
         "\000d\000i\000n\000g\000=\000'\000U\000T\000F\000-\0001\000\066"
         "\000'\000?\000>\000\n"
@@ -860,126 +838,113 @@ START_TEST(test_utf16)
         "\000s\000o\000m\000e\000 \xff\x21\000 \000t\000e\000x\000t\000"
         "<\000/\000d\000o\000c\000>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("some \xff21 text");
+  const XML_Char *expected = XCS("some \xff21 text");
 #else
-    const XML_Char *expected = XCS("some \357\274\241 text");
+  const XML_Char *expected = XCS("some \357\274\241 text");
 #endif
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, sizeof(text)-1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_utf16_le_epilog_newline)
-{
-    unsigned int first_chunk_bytes = 17;
-    char text[] = 
-        "\xFF\xFE"                      /* BOM */
-        "<\000e\000/\000>\000"          /* document element */
-        "\r\000\n\000\r\000\n\000";     /* epilog */
-
-    if (first_chunk_bytes >= sizeof(text) - 1)
-        fail("bad value of first_chunk_bytes");
-    if (  _XML_Parse_SINGLE_BYTES(parser, text, first_chunk_bytes, XML_FALSE)
-          == XML_STATUS_ERROR)
-        xml_failure(parser);
-    else {
-        enum XML_Status rc;
-        rc = _XML_Parse_SINGLE_BYTES(parser, text + first_chunk_bytes,
-                       sizeof(text) - first_chunk_bytes - 1, XML_TRUE);
-        if (rc == XML_STATUS_ERROR)
-            xml_failure(parser);
-    }
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_utf16_le_epilog_newline) {
+  unsigned int first_chunk_bytes = 17;
+  char text[] = "\xFF\xFE"                  /* BOM */
+                "<\000e\000/\000>\000"      /* document element */
+                "\r\000\n\000\r\000\n\000"; /* epilog */
+
+  if (first_chunk_bytes >= sizeof(text) - 1)
+    fail("bad value of first_chunk_bytes");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, first_chunk_bytes, XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  else {
+    enum XML_Status rc;
+    rc = _XML_Parse_SINGLE_BYTES(g_parser, text + first_chunk_bytes,
+                                 sizeof(text) - first_chunk_bytes - 1,
+                                 XML_TRUE);
+    if (rc == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+  }
 }
 END_TEST
 
 /* Test that an outright lie in the encoding is faulted */
-START_TEST(test_not_utf16)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-16'?>"
-        "<doc>Hi</doc>";
+START_TEST(test_not_utf16) {
+  const char *text = "<?xml version='1.0' encoding='utf-16'?>"
+                     "<doc>Hi</doc>";
 
-    /* Use a handler to provoke the appropriate code paths */
-    XML_SetXmlDeclHandler(parser, dummy_xdecl_handler);
-    expect_failure(text,
-                   XML_ERROR_INCORRECT_ENCODING,
-                   "UTF-16 declared in UTF-8 not faulted");
+  /* Use a handler to provoke the appropriate code paths */
+  XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
+  expect_failure(text, XML_ERROR_INCORRECT_ENCODING,
+                 "UTF-16 declared in UTF-8 not faulted");
 }
 END_TEST
 
 /* Test that an unknown encoding is rejected */
-START_TEST(test_bad_encoding)
-{
-    const char *text = "<doc>Hi</doc>";
+START_TEST(test_bad_encoding) {
+  const char *text = "<doc>Hi</doc>";
 
-    if (!XML_SetEncoding(parser, XCS("unknown-encoding")))
-        fail("XML_SetEncoding failed");
-    expect_failure(text,
-                   XML_ERROR_UNKNOWN_ENCODING,
-                   "Unknown encoding not faulted");
+  if (! XML_SetEncoding(g_parser, XCS("unknown-encoding")))
+    fail("XML_SetEncoding failed");
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Unknown encoding not faulted");
 }
 END_TEST
 
 /* Regression test for SF bug #481609, #774028. */
-START_TEST(test_latin1_umlauts)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+START_TEST(test_latin1_umlauts) {
+  const char *text
+      = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
         "<e a='\xE4 \xF6 \xFC &#228; &#246; &#252; &#x00E4; &#x0F6; &#xFC; >'\n"
         "  >\xE4 \xF6 \xFC &#228; &#246; &#252; &#x00E4; &#x0F6; &#xFC; ></e>";
 #ifdef XML_UNICODE
-    /* Expected results in UTF-16 */
-    const XML_Char *expected =
-        XCS("\x00e4 \x00f6 \x00fc ")
-        XCS("\x00e4 \x00f6 \x00fc ")
-        XCS("\x00e4 \x00f6 \x00fc >");
+  /* Expected results in UTF-16 */
+  const XML_Char *expected = XCS("\x00e4 \x00f6 \x00fc ")
+      XCS("\x00e4 \x00f6 \x00fc ") XCS("\x00e4 \x00f6 \x00fc >");
 #else
-    /* Expected results in UTF-8 */
-    const XML_Char *expected =
-        XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
-        XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
-        XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC >");
+  /* Expected results in UTF-8 */
+  const XML_Char *expected = XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ")
+      XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC ") XCS("\xC3\xA4 \xC3\xB6 \xC3\xBC >");
 #endif
 
-    run_character_check(text, expected);
-    XML_ParserReset(parser, NULL);
-    run_attribute_check(text, expected);
-    /* Repeat with a default handler */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-    run_character_check(text, expected);
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-    run_attribute_check(text, expected);
+  run_character_check(text, expected);
+  XML_ParserReset(g_parser, NULL);
+  run_attribute_check(text, expected);
+  /* Repeat with a default handler */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+  run_character_check(text, expected);
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+  run_attribute_check(text, expected);
 }
 END_TEST
 
 /* Test that an element name with a 4-byte UTF-8 character is rejected */
-START_TEST(test_long_utf8_character)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
+START_TEST(test_long_utf8_character) {
+  const char *text
+      = "<?xml version='1.0' encoding='utf-8'?>\n"
         /* 0xf0 0x90 0x80 0x80 = U+10000, the first Linear B character */
         "<do\xf0\x90\x80\x80/>";
-    expect_failure(text,
-                   XML_ERROR_INVALID_TOKEN,
-                   "4-byte UTF-8 character in element name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "4-byte UTF-8 character in element name not faulted");
 }
 END_TEST
 
 /* Test that a long latin-1 attribute (too long to convert in one go)
  * is correctly converted
  */
-START_TEST(test_long_latin1_attribute)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>\n"
+START_TEST(test_long_latin1_attribute) {
+  const char *text
+      = "<?xml version='1.0' encoding='iso-8859-1'?>\n"
         "<doc att='"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -1000,9 +965,10 @@ START_TEST(test_long_latin1_attribute)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         /* Last character splits across a buffer boundary */
         "\xe4'>\n</doc>";
-#ifdef XML_UNICODE
-    const XML_Char *expected =
-        /* 64 characters per line */
+
+  const XML_Char *expected =
+      /* 64 characters per line */
+      /* clang-format off */
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
@@ -1019,41 +985,23 @@ START_TEST(test_long_latin1_attribute)
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO")
-        XCS("\x00e4");
+  /* clang-format on */
+#ifdef XML_UNICODE
+                                                  XCS("\x00e4");
 #else
-    const XML_Char *expected =
-        /* 64 characters per line */
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO")
-        XCS("\xc3\xa4");
+                                                  XCS("\xc3\xa4");
 #endif
 
-    run_attribute_check(text, expected);
+  run_attribute_check(text, expected);
 }
 END_TEST
 
-
 /* Test that a long ASCII attribute (too long to convert in one go)
  * is correctly converted
  */
-START_TEST(test_long_ascii_attribute)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
+START_TEST(test_long_ascii_attribute) {
+  const char *text
+      = "<?xml version='1.0' encoding='us-ascii'?>\n"
         "<doc att='"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -1073,8 +1021,9 @@ START_TEST(test_long_ascii_attribute)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "01234'>\n</doc>";
-    const XML_Char *expected =
-        /* 64 characters per line */
+  const XML_Char *expected =
+      /* 64 characters per line */
+      /* clang-format off */
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
@@ -1092,47 +1041,45 @@ START_TEST(test_long_ascii_attribute)
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("01234");
+  /* clang-format on */
 
-    run_attribute_check(text, expected);
+  run_attribute_check(text, expected);
 }
 END_TEST
 
 /* Regression test #1 for SF bug #653180. */
-START_TEST(test_line_number_after_parse)
-{  
-    const char *text =
-        "<tag>\n"
-        "\n"
-        "\n</tag>";
-    XML_Size lineno;
-
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    lineno = XML_GetCurrentLineNumber(parser);
-    if (lineno != 4) {
-        char buffer[100];
-        sprintf(buffer, 
-            "expected 4 lines, saw %" XML_FMT_INT_MOD "u", lineno);
-        fail(buffer);
-    }
+START_TEST(test_line_number_after_parse) {
+  const char *text = "<tag>\n"
+                     "\n"
+                     "\n</tag>";
+  XML_Size lineno;
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  lineno = XML_GetCurrentLineNumber(g_parser);
+  if (lineno != 4) {
+    char buffer[100];
+    sprintf(buffer, "expected 4 lines, saw %" XML_FMT_INT_MOD "u", lineno);
+    fail(buffer);
+  }
 }
 END_TEST
 
 /* Regression test #2 for SF bug #653180. */
-START_TEST(test_column_number_after_parse)
-{
-    const char *text = "<tag></tag>";
-    XML_Size colno;
-
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    colno = XML_GetCurrentColumnNumber(parser);
-    if (colno != 11) {
-        char buffer[100];
-        sprintf(buffer, 
-            "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno);
-        fail(buffer);
-    }
+START_TEST(test_column_number_after_parse) {
+  const char *text = "<tag></tag>";
+  XML_Size colno;
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  colno = XML_GetCurrentColumnNumber(g_parser);
+  if (colno != 11) {
+    char buffer[100];
+    sprintf(buffer, "expected 11 columns, saw %" XML_FMT_INT_MOD "u", colno);
+    fail(buffer);
+  }
 }
 END_TEST
 
@@ -1140,115 +1087,99 @@ END_TEST
 #define STRUCT_END_TAG 1
 static void XMLCALL
 start_element_event_handler2(void *userData, const XML_Char *name,
-			     const XML_Char **UNUSED_P(attr))
-{
-    StructData *storage = (StructData *) userData;
-    StructData_AddItem(storage, name,
-                       XML_GetCurrentColumnNumber(parser),
-                       XML_GetCurrentLineNumber(parser),
-                       STRUCT_START_TAG);
+                             const XML_Char **attr) {
+  StructData *storage = (StructData *)userData;
+  UNUSED_P(attr);
+  StructData_AddItem(storage, name, XML_GetCurrentColumnNumber(g_parser),
+                     XML_GetCurrentLineNumber(g_parser), STRUCT_START_TAG);
 }
 
 static void XMLCALL
-end_element_event_handler2(void *userData, const XML_Char *name)
-{
-    StructData *storage = (StructData *) userData;
-    StructData_AddItem(storage, name,
-                       XML_GetCurrentColumnNumber(parser),
-                       XML_GetCurrentLineNumber(parser),
-                       STRUCT_END_TAG);
+end_element_event_handler2(void *userData, const XML_Char *name) {
+  StructData *storage = (StructData *)userData;
+  StructData_AddItem(storage, name, XML_GetCurrentColumnNumber(g_parser),
+                     XML_GetCurrentLineNumber(g_parser), STRUCT_END_TAG);
 }
 
 /* Regression test #3 for SF bug #653180. */
-START_TEST(test_line_and_column_numbers_inside_handlers)
-{
-    const char *text =
-        "<a>\n"        /* Unix end-of-line */
-        "  <b>\r\n"    /* Windows end-of-line */
-        "    <c/>\r"   /* Mac OS end-of-line */
-        "  </b>\n"
-        "  <d>\n"
-        "    <f/>\n"
-        "  </d>\n"
-        "</a>";
-    const StructDataEntry expected[] = {
-        { XCS("a"), 0, 1, STRUCT_START_TAG },
-        { XCS("b"), 2, 2, STRUCT_START_TAG },
-        { XCS("c"), 4, 3, STRUCT_START_TAG },
-        { XCS("c"), 8, 3, STRUCT_END_TAG },
-        { XCS("b"), 2, 4, STRUCT_END_TAG },
-        { XCS("d"), 2, 5, STRUCT_START_TAG },
-        { XCS("f"), 4, 6, STRUCT_START_TAG },
-        { XCS("f"), 8, 6, STRUCT_END_TAG },
-        { XCS("d"), 2, 7, STRUCT_END_TAG },
-        { XCS("a"), 0, 8, STRUCT_END_TAG }
-    };
-    const int expected_count = sizeof(expected) / sizeof(StructDataEntry);
-    StructData storage;
-
-    StructData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetStartElementHandler(parser, start_element_event_handler2);
-    XML_SetEndElementHandler(parser, end_element_event_handler2);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    StructData_CheckItems(&storage, expected, expected_count);
-    StructData_Dispose(&storage);
+START_TEST(test_line_and_column_numbers_inside_handlers) {
+  const char *text = "<a>\n"      /* Unix end-of-line */
+                     "  <b>\r\n"  /* Windows end-of-line */
+                     "    <c/>\r" /* Mac OS end-of-line */
+                     "  </b>\n"
+                     "  <d>\n"
+                     "    <f/>\n"
+                     "  </d>\n"
+                     "</a>";
+  const StructDataEntry expected[]
+      = {{XCS("a"), 0, 1, STRUCT_START_TAG}, {XCS("b"), 2, 2, STRUCT_START_TAG},
+         {XCS("c"), 4, 3, STRUCT_START_TAG}, {XCS("c"), 8, 3, STRUCT_END_TAG},
+         {XCS("b"), 2, 4, STRUCT_END_TAG},   {XCS("d"), 2, 5, STRUCT_START_TAG},
+         {XCS("f"), 4, 6, STRUCT_START_TAG}, {XCS("f"), 8, 6, STRUCT_END_TAG},
+         {XCS("d"), 2, 7, STRUCT_END_TAG},   {XCS("a"), 0, 8, STRUCT_END_TAG}};
+  const int expected_count = sizeof(expected) / sizeof(StructDataEntry);
+  StructData storage;
+
+  StructData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetStartElementHandler(g_parser, start_element_event_handler2);
+  XML_SetEndElementHandler(g_parser, end_element_event_handler2);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  StructData_CheckItems(&storage, expected, expected_count);
+  StructData_Dispose(&storage);
 }
 END_TEST
 
 /* Regression test #4 for SF bug #653180. */
-START_TEST(test_line_number_after_error)
-{
-    const char *text =
-        "<a>\n"
-        "  <b>\n"
-        "  </a>";  /* missing </b> */
-    XML_Size lineno;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_FALSE) != XML_STATUS_ERROR)
-        fail("Expected a parse error");
-
-    lineno = XML_GetCurrentLineNumber(parser);
-    if (lineno != 3) {
-        char buffer[100];
-        sprintf(buffer, "expected 3 lines, saw %" XML_FMT_INT_MOD "u", lineno);
-        fail(buffer);
-    }
+START_TEST(test_line_number_after_error) {
+  const char *text = "<a>\n"
+                     "  <b>\n"
+                     "  </a>"; /* missing </b> */
+  XML_Size lineno;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      != XML_STATUS_ERROR)
+    fail("Expected a parse error");
+
+  lineno = XML_GetCurrentLineNumber(g_parser);
+  if (lineno != 3) {
+    char buffer[100];
+    sprintf(buffer, "expected 3 lines, saw %" XML_FMT_INT_MOD "u", lineno);
+    fail(buffer);
+  }
 }
 END_TEST
-    
+
 /* Regression test #5 for SF bug #653180. */
-START_TEST(test_column_number_after_error)
-{
-    const char *text =
-        "<a>\n"
-        "  <b>\n"
-        "  </a>";  /* missing </b> */
-    XML_Size colno;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_FALSE) != XML_STATUS_ERROR)
-        fail("Expected a parse error");
-
-    colno = XML_GetCurrentColumnNumber(parser);
-    if (colno != 4) { 
-        char buffer[100];
-        sprintf(buffer, 
-            "expected 4 columns, saw %" XML_FMT_INT_MOD "u", colno);
-        fail(buffer);
-    }
+START_TEST(test_column_number_after_error) {
+  const char *text = "<a>\n"
+                     "  <b>\n"
+                     "  </a>"; /* missing </b> */
+  XML_Size colno;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      != XML_STATUS_ERROR)
+    fail("Expected a parse error");
+
+  colno = XML_GetCurrentColumnNumber(g_parser);
+  if (colno != 4) {
+    char buffer[100];
+    sprintf(buffer, "expected 4 columns, saw %" XML_FMT_INT_MOD "u", colno);
+    fail(buffer);
+  }
 }
 END_TEST
 
 /* Regression test for SF bug #478332. */
-START_TEST(test_really_long_lines)
-{
-    /* This parses an input line longer than INIT_DATA_BUF_SIZE
-       characters long (defined to be 1024 in xmlparse.c).  We take a
-       really cheesy approach to building the input buffer, because
-       this avoids writing bugs in buffer-filling code.
-    */
-    const char *text =
-        "<e>"
+START_TEST(test_really_long_lines) {
+  /* This parses an input line longer than INIT_DATA_BUF_SIZE
+     characters long (defined to be 1024 in xmlparse.c).  We take a
+     really cheesy approach to building the input buffer, because
+     this avoids writing bugs in buffer-filling code.
+  */
+  const char *text
+      = "<e>"
         /* 64 chars */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         /* until we have at least 1024 characters on the line: */
@@ -1269,21 +1200,21 @@ START_TEST(test_really_long_lines)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "</e>";
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test cdata processing across a buffer boundary */
-START_TEST(test_really_long_encoded_lines)
-{
-    /* As above, except that we want to provoke an output buffer
-     * overflow with a non-trivial encoding.  For this we need to pass
-     * the whole cdata in one go, not byte-by-byte.
-     */
-    void *buffer;
-    const char *text =
-        "<?xml version='1.0' encoding='iso-8859-1'?>"
+START_TEST(test_really_long_encoded_lines) {
+  /* As above, except that we want to provoke an output buffer
+   * overflow with a non-trivial encoding.  For this we need to pass
+   * the whole cdata in one go, not byte-by-byte.
+   */
+  void *buffer;
+  const char *text
+      = "<?xml version='1.0' encoding='iso-8859-1'?>"
         "<e>"
         /* 64 chars */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
@@ -1305,56 +1236,53 @@ START_TEST(test_really_long_encoded_lines)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "</e>";
-    int parse_len = (int)strlen(text);
+  int parse_len = (int)strlen(text);
 
-    /* Need a cdata handler to provoke the code path we want to test */
-    XML_SetCharacterDataHandler(parser, dummy_cdata_handler);
-    buffer = XML_GetBuffer(parser, parse_len);
-    if (buffer == NULL)
-        fail("Could not allocate parse buffer");
-    memcpy(buffer, text, parse_len);
-    if (XML_ParseBuffer(parser, parse_len, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  /* Need a cdata handler to provoke the code path we want to test */
+  XML_SetCharacterDataHandler(g_parser, dummy_cdata_handler);
+  buffer = XML_GetBuffer(g_parser, parse_len);
+  if (buffer == NULL)
+    fail("Could not allocate parse buffer");
+  assert(buffer != NULL);
+  memcpy(buffer, text, parse_len);
+  if (XML_ParseBuffer(g_parser, parse_len, XML_TRUE) == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
 /*
  * Element event tests.
  */
 
 static void XMLCALL
-start_element_event_handler(void *userData,
-                            const XML_Char *name,
-                            const XML_Char **UNUSED_P(atts))
-{
-    CharData_AppendXMLChars((CharData *)userData, name, -1);
+start_element_event_handler(void *userData, const XML_Char *name,
+                            const XML_Char **atts) {
+  UNUSED_P(atts);
+  CharData_AppendXMLChars((CharData *)userData, name, -1);
 }
 
 static void XMLCALL
-end_element_event_handler(void *userData, const XML_Char *name)
-{
-    CharData *storage = (CharData *) userData;
-    CharData_AppendXMLChars(storage, XCS("/"), 1);
-    CharData_AppendXMLChars(storage, name, -1);
+end_element_event_handler(void *userData, const XML_Char *name) {
+  CharData *storage = (CharData *)userData;
+  CharData_AppendXMLChars(storage, XCS("/"), 1);
+  CharData_AppendXMLChars(storage, name, -1);
 }
 
-START_TEST(test_end_element_events)
-{
-    const char *text = "<a><b><c/></b><d><f/></d></a>";
-    const XML_Char *expected = XCS("/c/b/f/d/a");
-    CharData storage;
+START_TEST(test_end_element_events) {
+  const char *text = "<a><b><c/></b><d><f/></d></a>";
+  const XML_Char *expected = XCS("/c/b/f/d/a");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetEndElementHandler(parser, end_element_event_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetEndElementHandler(g_parser, end_element_event_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-
 /*
  * Attribute tests.
  */
@@ -1369,85 +1297,82 @@ END_TEST
    attribute data types do.  (Section 3.3.3 of the recommendation.)
 */
 static int
-is_whitespace_normalized(const XML_Char *s, int is_cdata)
-{
-    int blanks = 0;
-    int at_start = 1;
-    while (*s) {
-        if (*s == XCS(' '))
-            ++blanks;
-        else if (*s == XCS('\t') || *s == XCS('\n') || *s == XCS('\r'))
-            return 0;
-        else {
-            if (at_start) {
-                at_start = 0;
-                if (blanks && !is_cdata)
-                    /* illegal leading blanks */
-                    return 0;
-            }
-            else if (blanks > 1 && !is_cdata)
-                return 0;
-            blanks = 0;
-        }
-        ++s;
-    }
-    if (blanks && !is_cdata)
+is_whitespace_normalized(const XML_Char *s, int is_cdata) {
+  int blanks = 0;
+  int at_start = 1;
+  while (*s) {
+    if (*s == XCS(' '))
+      ++blanks;
+    else if (*s == XCS('\t') || *s == XCS('\n') || *s == XCS('\r'))
+      return 0;
+    else {
+      if (at_start) {
+        at_start = 0;
+        if (blanks && ! is_cdata)
+          /* illegal leading blanks */
+          return 0;
+      } else if (blanks > 1 && ! is_cdata)
         return 0;
-    return 1;
+      blanks = 0;
+    }
+    ++s;
+  }
+  if (blanks && ! is_cdata)
+    return 0;
+  return 1;
 }
 
 /* Check the attribute whitespace checker: */
 static void
-testhelper_is_whitespace_normalized(void)
-{
-    assert(is_whitespace_normalized(XCS("abc"), 0));
-    assert(is_whitespace_normalized(XCS("abc"), 1));
-    assert(is_whitespace_normalized(XCS("abc def ghi"), 0));
-    assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
-    assert(!is_whitespace_normalized(XCS(" abc def ghi"), 0));
-    assert(is_whitespace_normalized(XCS(" abc def ghi"), 1));
-    assert(!is_whitespace_normalized(XCS("abc  def ghi"), 0));
-    assert(is_whitespace_normalized(XCS("abc  def ghi"), 1));
-    assert(!is_whitespace_normalized(XCS("abc def ghi "), 0));
-    assert(is_whitespace_normalized(XCS("abc def ghi "), 1));
-    assert(!is_whitespace_normalized(XCS(" "), 0));
-    assert(is_whitespace_normalized(XCS(" "), 1));
-    assert(!is_whitespace_normalized(XCS("\t"), 0));
-    assert(!is_whitespace_normalized(XCS("\t"), 1));
-    assert(!is_whitespace_normalized(XCS("\n"), 0));
-    assert(!is_whitespace_normalized(XCS("\n"), 1));
-    assert(!is_whitespace_normalized(XCS("\r"), 0));
-    assert(!is_whitespace_normalized(XCS("\r"), 1));
-    assert(!is_whitespace_normalized(XCS("abc\t def"), 1));
+testhelper_is_whitespace_normalized(void) {
+  assert(is_whitespace_normalized(XCS("abc"), 0));
+  assert(is_whitespace_normalized(XCS("abc"), 1));
+  assert(is_whitespace_normalized(XCS("abc def ghi"), 0));
+  assert(is_whitespace_normalized(XCS("abc def ghi"), 1));
+  assert(! is_whitespace_normalized(XCS(" abc def ghi"), 0));
+  assert(is_whitespace_normalized(XCS(" abc def ghi"), 1));
+  assert(! is_whitespace_normalized(XCS("abc  def ghi"), 0));
+  assert(is_whitespace_normalized(XCS("abc  def ghi"), 1));
+  assert(! is_whitespace_normalized(XCS("abc def ghi "), 0));
+  assert(is_whitespace_normalized(XCS("abc def ghi "), 1));
+  assert(! is_whitespace_normalized(XCS(" "), 0));
+  assert(is_whitespace_normalized(XCS(" "), 1));
+  assert(! is_whitespace_normalized(XCS("\t"), 0));
+  assert(! is_whitespace_normalized(XCS("\t"), 1));
+  assert(! is_whitespace_normalized(XCS("\n"), 0));
+  assert(! is_whitespace_normalized(XCS("\n"), 1));
+  assert(! is_whitespace_normalized(XCS("\r"), 0));
+  assert(! is_whitespace_normalized(XCS("\r"), 1));
+  assert(! is_whitespace_normalized(XCS("abc\t def"), 1));
 }
 
 static void XMLCALL
-check_attr_contains_normalized_whitespace(void *UNUSED_P(userData),
-                                          const XML_Char *UNUSED_P(name),
-                                          const XML_Char **atts)
-{
-    int i;
-    for (i = 0; atts[i] != NULL; i += 2) {
-        const XML_Char *attrname = atts[i];
-        const XML_Char *value = atts[i + 1];
-        if (xcstrcmp(XCS("attr"), attrname) == 0
-            || xcstrcmp(XCS("ents"), attrname) == 0
-            || xcstrcmp(XCS("refs"), attrname) == 0) {
-            if (!is_whitespace_normalized(value, 0)) {
-                char buffer[256];
-                sprintf(buffer, "attribute value not normalized: %"
-                        XML_FMT_STR "='%" XML_FMT_STR "'",
-                        attrname, value);
-                fail(buffer);
-            }
-        }
+check_attr_contains_normalized_whitespace(void *userData, const XML_Char *name,
+                                          const XML_Char **atts) {
+  int i;
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  for (i = 0; atts[i] != NULL; i += 2) {
+    const XML_Char *attrname = atts[i];
+    const XML_Char *value = atts[i + 1];
+    if (xcstrcmp(XCS("attr"), attrname) == 0
+        || xcstrcmp(XCS("ents"), attrname) == 0
+        || xcstrcmp(XCS("refs"), attrname) == 0) {
+      if (! is_whitespace_normalized(value, 0)) {
+        char buffer[256];
+        sprintf(buffer,
+                "attribute value not normalized: %" XML_FMT_STR
+                "='%" XML_FMT_STR "'",
+                attrname, value);
+        fail(buffer);
+      }
     }
+  }
 }
 
-START_TEST(test_attr_whitespace_normalization)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_attr_whitespace_normalization) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ATTLIST doc\n"
         "            attr NMTOKENS #REQUIRED\n"
         "            ents ENTITIES #REQUIRED\n"
@@ -1460,289 +1385,253 @@ START_TEST(test_attr_whitespace_normalization)
         "  <e id='id-2'/>\n"
         "</doc>";
 
-    XML_SetStartElementHandler(parser,
-                               check_attr_contains_normalized_whitespace);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetStartElementHandler(g_parser,
+                             check_attr_contains_normalized_whitespace);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
 /*
  * XML declaration tests.
  */
 
-START_TEST(test_xmldecl_misplaced)
-{
-    expect_failure("\n"
-                   "<?xml version='1.0'?>\n"
-                   "<a/>",
-                   XML_ERROR_MISPLACED_XML_PI,
-                   "failed to report misplaced XML declaration");
+START_TEST(test_xmldecl_misplaced) {
+  expect_failure("\n"
+                 "<?xml version='1.0'?>\n"
+                 "<a/>",
+                 XML_ERROR_MISPLACED_XML_PI,
+                 "failed to report misplaced XML declaration");
 }
 END_TEST
 
-START_TEST(test_xmldecl_invalid)
-{
-    expect_failure("<?xml version='1.0' \xc3\xa7?>\n<doc/>",
-                   XML_ERROR_XML_DECL,
-                   "Failed to report invalid XML declaration");
+START_TEST(test_xmldecl_invalid) {
+  expect_failure("<?xml version='1.0' \xc3\xa7?>\n<doc/>", XML_ERROR_XML_DECL,
+                 "Failed to report invalid XML declaration");
 }
 END_TEST
 
-START_TEST(test_xmldecl_missing_attr)
-{
-    expect_failure("<?xml ='1.0'?>\n<doc/>\n",
-                   XML_ERROR_XML_DECL,
-                   "Failed to report missing XML declaration attribute");
+START_TEST(test_xmldecl_missing_attr) {
+  expect_failure("<?xml ='1.0'?>\n<doc/>\n", XML_ERROR_XML_DECL,
+                 "Failed to report missing XML declaration attribute");
 }
 END_TEST
 
-START_TEST(test_xmldecl_missing_value)
-{
-    expect_failure("<?xml version='1.0' encoding='us-ascii' standalone?>\n"
-                   "<doc/>",
-                   XML_ERROR_XML_DECL,
-                   "Failed to report missing attribute value");
+START_TEST(test_xmldecl_missing_value) {
+  expect_failure("<?xml version='1.0' encoding='us-ascii' standalone?>\n"
+                 "<doc/>",
+                 XML_ERROR_XML_DECL,
+                 "Failed to report missing attribute value");
 }
 END_TEST
 
 /* Regression test for SF bug #584832. */
 static int XMLCALL
-UnknownEncodingHandler(void *UNUSED_P(data),const XML_Char *encoding,XML_Encoding *info)
-{
-    if (xcstrcmp(encoding, XCS("unsupported-encoding")) == 0) {
-        int i;
-        for (i = 0; i < 256; ++i)
-            info->map[i] = i;
-        info->data = NULL;
-        info->convert = NULL;
-        info->release = NULL;
-        return XML_STATUS_OK;
-    }
-    return XML_STATUS_ERROR;
+UnknownEncodingHandler(void *data, const XML_Char *encoding,
+                       XML_Encoding *info) {
+  UNUSED_P(data);
+  if (xcstrcmp(encoding, XCS("unsupported-encoding")) == 0) {
+    int i;
+    for (i = 0; i < 256; ++i)
+      info->map[i] = i;
+    info->data = NULL;
+    info->convert = NULL;
+    info->release = NULL;
+    return XML_STATUS_OK;
+  }
+  return XML_STATUS_ERROR;
 }
 
-START_TEST(test_unknown_encoding_internal_entity)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
-        "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
-        "<test a='&foo;'/>";
+START_TEST(test_unknown_encoding_internal_entity) {
+  const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
+                     "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
+                     "<test a='&foo;'/>";
 
-    XML_SetUnknownEncodingHandler(parser, UnknownEncodingHandler, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetUnknownEncodingHandler(g_parser, UnknownEncodingHandler, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test unrecognised encoding handler */
-static void dummy_release(void *UNUSED_P(data))
-{
+static void
+dummy_release(void *data) {
+  UNUSED_P(data);
 }
 
 static int XMLCALL
-UnrecognisedEncodingHandler(void *UNUSED_P(data),
-                            const XML_Char *UNUSED_P(encoding),
-                            XML_Encoding *info)
-{
-    info->data = NULL;
-    info->convert = NULL;
-    info->release = dummy_release;
-    return XML_STATUS_ERROR;
+UnrecognisedEncodingHandler(void *data, const XML_Char *encoding,
+                            XML_Encoding *info) {
+  UNUSED_P(data);
+  UNUSED_P(encoding);
+  info->data = NULL;
+  info->convert = NULL;
+  info->release = dummy_release;
+  return XML_STATUS_ERROR;
 }
 
-START_TEST(test_unrecognised_encoding_internal_entity)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
-        "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
-        "<test a='&foo;'/>";
+START_TEST(test_unrecognised_encoding_internal_entity) {
+  const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
+                     "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
+                     "<test a='&foo;'/>";
 
-    XML_SetUnknownEncodingHandler(parser,
-                                  UnrecognisedEncodingHandler,
-                                  NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Unrecognised encoding not rejected");
+  XML_SetUnknownEncodingHandler(g_parser, UnrecognisedEncodingHandler, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Unrecognised encoding not rejected");
 }
 END_TEST
 
 /* Regression test for SF bug #620106. */
 static int XMLCALL
-external_entity_loader(XML_Parser parser,
-                       const XML_Char *context,
-                       const XML_Char *UNUSED_P(base),
-                       const XML_Char *UNUSED_P(systemId),
-                       const XML_Char *UNUSED_P(publicId))
-{
-    ExtTest *test_data = (ExtTest *)XML_GetUserData(parser);
-    XML_Parser extparser;
-
-    extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (extparser == NULL)
-        fail("Could not create external entity parser.");
-    if (test_data->encoding != NULL) {
-        if (!XML_SetEncoding(extparser, test_data->encoding))
-            fail("XML_SetEncoding() ignored for external entity");
-    }
-    if ( _XML_Parse_SINGLE_BYTES(extparser,
-                                 test_data->parse_text,
-                                 (int)strlen(test_data->parse_text),
-                                 XML_TRUE)
-          == XML_STATUS_ERROR) {
-        xml_failure(extparser);
-        return XML_STATUS_ERROR;
-    }
-    XML_ParserFree(extparser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ext_entity_set_encoding)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest test_data = {
-        /* This text says it's an unsupported encoding, but it's really
-           UTF-8, which we tell Expat using XML_SetEncoding().
-        */
-        "<?xml encoding='iso-8859-3'?>\xC3\xA9",
-        XCS("utf-8"),
-        NULL
-    };
+external_entity_loader(XML_Parser parser, const XML_Char *context,
+                       const XML_Char *base, const XML_Char *systemId,
+                       const XML_Char *publicId) {
+  ExtTest *test_data = (ExtTest *)XML_GetUserData(parser);
+  XML_Parser extparser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (extparser == NULL)
+    fail("Could not create external entity parser.");
+  if (test_data->encoding != NULL) {
+    if (! XML_SetEncoding(extparser, test_data->encoding))
+      fail("XML_SetEncoding() ignored for external entity");
+  }
+  if (_XML_Parse_SINGLE_BYTES(extparser, test_data->parse_text,
+                              (int)strlen(test_data->parse_text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(extparser);
+    return XML_STATUS_ERROR;
+  }
+  XML_ParserFree(extparser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ext_entity_set_encoding) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest test_data
+      = {/* This text says it's an unsupported encoding, but it's really
+            UTF-8, which we tell Expat using XML_SetEncoding().
+         */
+         "<?xml encoding='iso-8859-3'?>\xC3\xA9", XCS("utf-8"), NULL};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e9");
+  const XML_Char *expected = XCS("\x00e9");
 #else
-    const XML_Char *expected = XCS("\xc3\xa9");
+  const XML_Char *expected = XCS("\xc3\xa9");
 #endif
 
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    run_ext_character_check(text, &test_data, expected);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  run_ext_character_check(text, &test_data, expected);
 }
 END_TEST
 
 /* Test external entities with no handler */
-START_TEST(test_ext_entity_no_handler)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
+START_TEST(test_ext_entity_no_handler) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
 
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-    run_character_check(text, XCS(""));
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+  run_character_check(text, XCS(""));
 }
 END_TEST
 
 /* Test UTF-8 BOM is accepted */
-START_TEST(test_ext_entity_set_bom)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest test_data = {
-        "\xEF\xBB\xBF" /* BOM */
-        "<?xml encoding='iso-8859-3'?>"
-        "\xC3\xA9",
-        XCS("utf-8"),
-        NULL
-    };
+START_TEST(test_ext_entity_set_bom) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest test_data = {"\xEF\xBB\xBF" /* BOM */
+                       "<?xml encoding='iso-8859-3'?>"
+                       "\xC3\xA9",
+                       XCS("utf-8"), NULL};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e9");
+  const XML_Char *expected = XCS("\x00e9");
 #else
-    const XML_Char *expected = XCS("\xc3\xa9");
+  const XML_Char *expected = XCS("\xc3\xa9");
 #endif
 
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    run_ext_character_check(text, &test_data, expected);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  run_ext_character_check(text, &test_data, expected);
 }
 END_TEST
 
-
 /* Test that bad encodings are faulted */
-typedef struct ext_faults
-{
-    const char *parse_text;
-    const char *fail_text;
-    const XML_Char *encoding;
-    enum XML_Error error;
+typedef struct ext_faults {
+  const char *parse_text;
+  const char *fail_text;
+  const XML_Char *encoding;
+  enum XML_Error error;
 } ExtFaults;
 
 static int XMLCALL
-external_entity_faulter(XML_Parser parser,
-                        const XML_Char *context,
-                        const XML_Char *UNUSED_P(base),
-                        const XML_Char *UNUSED_P(systemId),
-                        const XML_Char *UNUSED_P(publicId))
-{
-    XML_Parser ext_parser;
-    ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (fault->encoding != NULL) {
-        if (!XML_SetEncoding(ext_parser, fault->encoding))
-            fail("XML_SetEncoding failed");
-    }
-    if (_XML_Parse_SINGLE_BYTES(ext_parser,
-                                fault->parse_text,
-                                (int)strlen(fault->parse_text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail(fault->fail_text);
-    if (XML_GetErrorCode(ext_parser) != fault->error)
-        xml_failure(ext_parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_ERROR;
-}
-
-START_TEST(test_ext_entity_bad_encoding)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtFaults fault = {
-        "<?xml encoding='iso-8859-3'?>u",
-        "Unsupported encoding not faulted",
-        XCS("unknown"),
-        XML_ERROR_UNKNOWN_ENCODING
-    };
-
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    XML_SetUserData(parser, &fault);
-    expect_failure(text,
-                   XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Bad encoding should not have been accepted");
+external_entity_faulter(XML_Parser parser, const XML_Char *context,
+                        const XML_Char *base, const XML_Char *systemId,
+                        const XML_Char *publicId) {
+  XML_Parser ext_parser;
+  ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (fault->encoding != NULL) {
+    if (! XML_SetEncoding(ext_parser, fault->encoding))
+      fail("XML_SetEncoding failed");
+  }
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, fault->parse_text,
+                              (int)strlen(fault->parse_text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail(fault->fail_text);
+  if (XML_GetErrorCode(ext_parser) != fault->error)
+    xml_failure(ext_parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_ERROR;
+}
+
+START_TEST(test_ext_entity_bad_encoding) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtFaults fault
+      = {"<?xml encoding='iso-8859-3'?>u", "Unsupported encoding not faulted",
+         XCS("unknown"), XML_ERROR_UNKNOWN_ENCODING};
+
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  XML_SetUserData(g_parser, &fault);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Bad encoding should not have been accepted");
 }
 END_TEST
 
 /* Try handing an invalid encoding to an external entity parser */
-START_TEST(test_ext_entity_bad_encoding_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    ExtFaults fault = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        "Unknown encoding not faulted",
-        XCS("unknown-encoding"),
-        XML_ERROR_UNKNOWN_ENCODING
-    };
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    XML_SetUserData(parser, &fault);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Bad encoding not faulted in external entity handler");
+START_TEST(test_ext_entity_bad_encoding_2) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  ExtFaults fault
+      = {"<!ELEMENT doc (#PCDATA)*>", "Unknown encoding not faulted",
+         XCS("unknown-encoding"), XML_ERROR_UNKNOWN_ENCODING};
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  XML_SetUserData(g_parser, &fault);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Bad encoding not faulted in external entity handler");
 }
 END_TEST
 
@@ -1750,12 +1639,12 @@ END_TEST
    read an external subset.  This was fixed in Expat 1.95.5.
 */
 START_TEST(test_wfc_undeclared_entity_unread_external_subset) {
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
+  const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
@@ -1763,9 +1652,8 @@ END_TEST
    have an external subset.
 */
 START_TEST(test_wfc_undeclared_entity_no_external_subset) {
-    expect_failure("<doc>&entity;</doc>",
-                   XML_ERROR_UNDEFINED_ENTITY,
-                   "Parser did not report undefined entity w/out a DTD.");
+  expect_failure("<doc>&entity;</doc>", XML_ERROR_UNDEFINED_ENTITY,
+                 "Parser did not report undefined entity w/out a DTD.");
 }
 END_TEST
 
@@ -1773,14 +1661,13 @@ END_TEST
    read an external subset, but have been declared standalone.
 */
 START_TEST(test_wfc_undeclared_entity_standalone) {
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
+  const char *text
+      = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
         "<!DOCTYPE doc SYSTEM 'foo'>\n"
         "<doc>&entity;</doc>";
 
-    expect_failure(text,
-                   XML_ERROR_UNDEFINED_ENTITY,
-                   "Parser did not report undefined entity (standalone).");
+  expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
+                 "Parser did not report undefined entity (standalone).");
 }
 END_TEST
 
@@ -1788,22 +1675,17 @@ END_TEST
    an external subset, and standalone is true.
 */
 START_TEST(test_wfc_undeclared_entity_with_external_subset_standalone) {
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
+  const char *text
+      = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
         "<!DOCTYPE doc SYSTEM 'foo'>\n"
         "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    expect_failure(text,
-                   XML_ERROR_UNDEFINED_ENTITY,
-                   "Parser did not report undefined entity (external DTD).");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
+                 "Parser did not report undefined entity (external DTD).");
 }
 END_TEST
 
@@ -1811,19 +1693,18 @@ END_TEST
  * is set to UNLESS_STANDALONE
  */
 START_TEST(test_entity_with_external_subset_unless_standalone) {
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
+  const char *text
+      = "<?xml version='1.0' encoding='us-ascii' standalone='yes'?>\n"
         "<!DOCTYPE doc SYSTEM 'foo'>\n"
         "<doc>&entity;</doc>";
-    ExtTest test_data = { "<!ENTITY entity 'bar'>", NULL, NULL };
+  ExtTest test_data = {"<!ENTITY entity 'bar'>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser,
-                              XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    expect_failure(text,
-                   XML_ERROR_UNDEFINED_ENTITY,
-                   "Parser did not report undefined entity");
+  XML_SetParamEntityParsing(g_parser,
+                            XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
+                 "Parser did not report undefined entity");
 }
 END_TEST
 
@@ -1831,275 +1712,210 @@ END_TEST
    an external subset, and standalone is false.
 */
 START_TEST(test_wfc_undeclared_entity_with_external_subset) {
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    run_ext_character_check(text, &test_data, XCS(""));
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  run_ext_character_check(text, &test_data, XCS(""));
 }
 END_TEST
 
 /* Test that an error is reported if our NotStandalone handler fails */
 static int XMLCALL
-reject_not_standalone_handler(void *UNUSED_P(userData))
-{
-    return XML_STATUS_ERROR;
+reject_not_standalone_handler(void *userData) {
+  UNUSED_P(userData);
+  return XML_STATUS_ERROR;
 }
 
-START_TEST(test_not_standalone_handler_reject)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
+START_TEST(test_not_standalone_handler_reject) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetNotStandaloneHandler(parser, reject_not_standalone_handler);
-    expect_failure(text, XML_ERROR_NOT_STANDALONE,
-                   "NotStandalone handler failed to reject");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
+  expect_failure(text, XML_ERROR_NOT_STANDALONE,
+                 "NotStandalone handler failed to reject");
 
-    /* Try again but without external entity handling */
-    XML_ParserReset(parser, NULL);
-    XML_SetNotStandaloneHandler(parser, reject_not_standalone_handler);
-    expect_failure(text, XML_ERROR_NOT_STANDALONE,
-                   "NotStandalone handler failed to reject");
+  /* Try again but without external entity handling */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
+  expect_failure(text, XML_ERROR_NOT_STANDALONE,
+                 "NotStandalone handler failed to reject");
 }
 END_TEST
 
 /* Test that no error is reported if our NotStandalone handler succeeds */
 static int XMLCALL
-accept_not_standalone_handler(void *UNUSED_P(userData))
-{
-    return XML_STATUS_OK;
+accept_not_standalone_handler(void *userData) {
+  UNUSED_P(userData);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_not_standalone_handler_accept)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
+START_TEST(test_not_standalone_handler_accept) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetNotStandaloneHandler(parser, accept_not_standalone_handler);
-    run_ext_character_check(text, &test_data, XCS(""));
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetNotStandaloneHandler(g_parser, accept_not_standalone_handler);
+  run_ext_character_check(text, &test_data, XCS(""));
 
-    /* Repeat wtihout the external entity handler */
-    XML_ParserReset(parser, NULL);
-    XML_SetNotStandaloneHandler(parser, accept_not_standalone_handler);
-    run_character_check(text, XCS(""));
+  /* Repeat wtihout the external entity handler */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetNotStandaloneHandler(g_parser, accept_not_standalone_handler);
+  run_character_check(text, XCS(""));
 }
 END_TEST
 
-START_TEST(test_wfc_no_recursive_entity_refs)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY entity '&#38;entity;'>\n"
-        "]>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_wfc_no_recursive_entity_refs) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY entity '&#38;entity;'>\n"
+                     "]>\n"
+                     "<doc>&entity;</doc>";
 
-    expect_failure(text,
-                   XML_ERROR_RECURSIVE_ENTITY_REF,
-                   "Parser did not report recursive entity reference.");
+  expect_failure(text, XML_ERROR_RECURSIVE_ENTITY_REF,
+                 "Parser did not report recursive entity reference.");
 }
 END_TEST
 
 /* Test incomplete external entities are faulted */
-START_TEST(test_ext_entity_invalid_parse)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    const ExtFaults faults[] = {
-        {
-            "<",
-            "Incomplete element declaration not faulted",
-            NULL,
-            XML_ERROR_UNCLOSED_TOKEN
-        },
-        {
-            "<\xe2\x82", /* First two bytes of a three-byte char */
-            "Incomplete character not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        {
-            "<tag>\xe2\x82",
-            "Incomplete character in CDATA not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        { NULL, NULL, NULL, XML_ERROR_NONE }
-    };
-    const ExtFaults *fault = faults;
-
-    for (; fault->parse_text != NULL; fault++) {
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-        XML_SetUserData(parser, (void *)fault);
-        expect_failure(text,
-                       XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                       "Parser did not report external entity error");
-        XML_ParserReset(parser, NULL);
-    }
+START_TEST(test_ext_entity_invalid_parse) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  const ExtFaults faults[]
+      = {{"<", "Incomplete element declaration not faulted", NULL,
+          XML_ERROR_UNCLOSED_TOKEN},
+         {"<\xe2\x82", /* First two bytes of a three-byte char */
+          "Incomplete character not faulted", NULL, XML_ERROR_PARTIAL_CHAR},
+         {"<tag>\xe2\x82", "Incomplete character in CDATA not faulted", NULL,
+          XML_ERROR_PARTIAL_CHAR},
+         {NULL, NULL, NULL, XML_ERROR_NONE}};
+  const ExtFaults *fault = faults;
+
+  for (; fault->parse_text != NULL; fault++) {
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+    XML_SetUserData(g_parser, (void *)fault);
+    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                   "Parser did not report external entity error");
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
-
 /* Regression test for SF bug #483514. */
-START_TEST(test_dtd_default_handling)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
-        "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ATTLIST doc a CDATA #IMPLIED>\n"
-        "<?pi in dtd?>\n"
-        "<!--comment in dtd-->\n"
-        "]><doc/>";
-
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetStartDoctypeDeclHandler(parser, dummy_start_doctype_handler);
-    XML_SetEndDoctypeDeclHandler(parser, dummy_end_doctype_handler);
-    XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-    XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-    XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-    XML_SetCommentHandler(parser, dummy_comment_handler);
-    XML_SetStartCdataSectionHandler(parser, dummy_start_cdata_handler);
-    XML_SetEndCdataSectionHandler(parser, dummy_end_cdata_handler);
-    run_character_check(text, XCS("\n\n\n\n\n\n\n<doc/>"));
+START_TEST(test_dtd_default_handling) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
+                     "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
+                     "<!ELEMENT doc EMPTY>\n"
+                     "<!ATTLIST doc a CDATA #IMPLIED>\n"
+                     "<?pi in dtd?>\n"
+                     "<!--comment in dtd-->\n"
+                     "]><doc/>";
+
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
+  XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
+  XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+  XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+  XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+  XML_SetCommentHandler(g_parser, dummy_comment_handler);
+  XML_SetStartCdataSectionHandler(g_parser, dummy_start_cdata_handler);
+  XML_SetEndCdataSectionHandler(g_parser, dummy_end_cdata_handler);
+  run_character_check(text, XCS("\n\n\n\n\n\n\n<doc/>"));
 }
 END_TEST
 
 /* Test handling of attribute declarations */
 typedef struct AttTest {
-    const char *definition;
-    const XML_Char *element_name;
-    const XML_Char *attr_name;
-    const XML_Char *attr_type;
-    const XML_Char *default_value;
-    int is_required;
+  const char *definition;
+  const XML_Char *element_name;
+  const XML_Char *attr_name;
+  const XML_Char *attr_type;
+  const XML_Char *default_value;
+  int is_required;
 } AttTest;
 
 static void XMLCALL
-verify_attlist_decl_handler(void *userData,
-                            const XML_Char *element_name,
+verify_attlist_decl_handler(void *userData, const XML_Char *element_name,
                             const XML_Char *attr_name,
                             const XML_Char *attr_type,
-                            const XML_Char *default_value,
-                            int is_required)
-{
-    AttTest *at = (AttTest *)userData;
-
-    if (xcstrcmp(element_name, at->element_name))
-        fail("Unexpected element name in attribute declaration");
-    if (xcstrcmp(attr_name, at->attr_name))
-        fail("Unexpected attribute name in attribute declaration");
-    if (xcstrcmp(attr_type, at->attr_type))
-        fail("Unexpected attribute type in attribute declaration");
-    if ((default_value == NULL && at->default_value != NULL) ||
-        (default_value != NULL && at->default_value == NULL) ||
-        (default_value != NULL && xcstrcmp(default_value, at->default_value)))
-        fail("Unexpected default value in attribute declaration");
-    if (is_required != at->is_required)
-        fail("Requirement mismatch in attribute declaration");
-}
-
-START_TEST(test_dtd_attr_handling)
-{
-    const char *prolog =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc EMPTY>\n";
-    AttTest attr_data[] = {
-        {
-            "<!ATTLIST doc a ( one | two | three ) #REQUIRED>\n"
-            "]>"
-            "<doc a='two'/>",
-            XCS("doc"),
-            XCS("a"),
-            XCS("(one|two|three)"), /* Extraneous spaces will be removed */
-            NULL,
-            XML_TRUE
-        },
-        {
-            "<!NOTATION foo SYSTEM 'http://example.org/foo'>\n"
-            "<!ATTLIST doc a NOTATION (foo) #IMPLIED>\n"
-            "]>"
-            "<doc/>",
-            XCS("doc"),
-            XCS("a"),
-            XCS("NOTATION(foo)"),
-            NULL,
-            XML_FALSE
-        },
-        {
-            "<!ATTLIST doc a NOTATION (foo) 'bar'>\n"
-            "]>"
-            "<doc/>",
-            XCS("doc"),
-            XCS("a"),
-            XCS("NOTATION(foo)"),
-            XCS("bar"),
-            XML_FALSE
-        },
-        {
-            "<!ATTLIST doc a CDATA '\xdb\xb2'>\n"
-            "]>"
-            "<doc/>",
-            XCS("doc"),
-            XCS("a"),
-            XCS("CDATA"),
+                            const XML_Char *default_value, int is_required) {
+  AttTest *at = (AttTest *)userData;
+
+  if (xcstrcmp(element_name, at->element_name))
+    fail("Unexpected element name in attribute declaration");
+  if (xcstrcmp(attr_name, at->attr_name))
+    fail("Unexpected attribute name in attribute declaration");
+  if (xcstrcmp(attr_type, at->attr_type))
+    fail("Unexpected attribute type in attribute declaration");
+  if ((default_value == NULL && at->default_value != NULL)
+      || (default_value != NULL && at->default_value == NULL)
+      || (default_value != NULL && xcstrcmp(default_value, at->default_value)))
+    fail("Unexpected default value in attribute declaration");
+  if (is_required != at->is_required)
+    fail("Requirement mismatch in attribute declaration");
+}
+
+START_TEST(test_dtd_attr_handling) {
+  const char *prolog = "<!DOCTYPE doc [\n"
+                       "<!ELEMENT doc EMPTY>\n";
+  AttTest attr_data[]
+      = {{"<!ATTLIST doc a ( one | two | three ) #REQUIRED>\n"
+          "]>"
+          "<doc a='two'/>",
+          XCS("doc"), XCS("a"),
+          XCS("(one|two|three)"), /* Extraneous spaces will be removed */
+          NULL, XML_TRUE},
+         {"<!NOTATION foo SYSTEM 'http://example.org/foo'>\n"
+          "<!ATTLIST doc a NOTATION (foo) #IMPLIED>\n"
+          "]>"
+          "<doc/>",
+          XCS("doc"), XCS("a"), XCS("NOTATION(foo)"), NULL, XML_FALSE},
+         {"<!ATTLIST doc a NOTATION (foo) 'bar'>\n"
+          "]>"
+          "<doc/>",
+          XCS("doc"), XCS("a"), XCS("NOTATION(foo)"), XCS("bar"), XML_FALSE},
+         {"<!ATTLIST doc a CDATA '\xdb\xb2'>\n"
+          "]>"
+          "<doc/>",
+          XCS("doc"), XCS("a"), XCS("CDATA"),
 #ifdef XML_UNICODE
-            XCS("\x06f2"),
+          XCS("\x06f2"),
 #else
-            XCS("\xdb\xb2"),
+          XCS("\xdb\xb2"),
 #endif
-            XML_FALSE
-        },
-        { NULL, NULL, NULL, NULL, NULL, XML_FALSE }
-    };
-    AttTest *test;
-
-    for (test = attr_data; test->definition != NULL; test++) {
-        XML_SetAttlistDeclHandler(parser, verify_attlist_decl_handler);
-        XML_SetUserData(parser, test);
-        if (_XML_Parse_SINGLE_BYTES(parser, prolog, (int)strlen(prolog),
-                                    XML_FALSE) == XML_STATUS_ERROR)
-            xml_failure(parser);
-        if (_XML_Parse_SINGLE_BYTES(parser,
-                                    test->definition,
-                                    (int)strlen(test->definition),
-                                    XML_TRUE) == XML_STATUS_ERROR)
-            xml_failure(parser);
-        XML_ParserReset(parser, NULL);
-    }
+          XML_FALSE},
+         {NULL, NULL, NULL, NULL, NULL, XML_FALSE}};
+  AttTest *test;
+
+  for (test = attr_data; test->definition != NULL; test++) {
+    XML_SetAttlistDeclHandler(g_parser, verify_attlist_decl_handler);
+    XML_SetUserData(g_parser, test);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, prolog, (int)strlen(prolog),
+                                XML_FALSE)
+        == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, test->definition,
+                                (int)strlen(test->definition), XML_TRUE)
+        == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
@@ -2109,15 +1925,14 @@ END_TEST
    when namespace processing is not enabled.
    (See Namespaces in XML, section 2.)
 */
-START_TEST(test_empty_ns_without_namespaces)
-{
-    const char *text =
-        "<doc xmlns:prefix='http://example.org/'>\n"
-        "  <e xmlns:prefix=''/>\n"
-        "</doc>";
+START_TEST(test_empty_ns_without_namespaces) {
+  const char *text = "<doc xmlns:prefix='http://example.org/'>\n"
+                     "  <e xmlns:prefix=''/>\n"
+                     "</doc>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
@@ -2125,238 +1940,242 @@ END_TEST
    Checks that an xmlns:prefix attribute set in an attribute's default
    value isn't misinterpreted.
 */
-START_TEST(test_ns_in_attribute_default_without_namespaces)
-{
-    const char *text =
-        "<!DOCTYPE e:element [\n"
-        "  <!ATTLIST e:element\n"
-        "    xmlns:e CDATA 'http://example.org/'>\n"
-        "      ]>\n"
-        "<e:element/>";
-
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-}
-END_TEST
-
-static const char *long_character_data_text =
-    "<?xml version='1.0' encoding='iso-8859-1'?><s>"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "</s>";
+START_TEST(test_ns_in_attribute_default_without_namespaces) {
+  const char *text = "<!DOCTYPE e:element [\n"
+                     "  <!ATTLIST e:element\n"
+                     "    xmlns:e CDATA 'http://example.org/'>\n"
+                     "      ]>\n"
+                     "<e:element/>";
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+}
+END_TEST
+
+static const char *long_character_data_text
+    = "<?xml version='1.0' encoding='iso-8859-1'?><s>"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "</s>";
 
 static XML_Bool resumable = XML_FALSE;
 
 static void
-clearing_aborting_character_handler(void *UNUSED_P(userData),
-                                    const XML_Char *UNUSED_P(s), int UNUSED_P(len))
-{
-    XML_StopParser(parser, resumable);
-    XML_SetCharacterDataHandler(parser, NULL);
+clearing_aborting_character_handler(void *userData, const XML_Char *s,
+                                    int len) {
+  UNUSED_P(userData);
+  UNUSED_P(s);
+  UNUSED_P(len);
+  XML_StopParser(g_parser, resumable);
+  XML_SetCharacterDataHandler(g_parser, NULL);
 }
 
 /* Regression test for SF bug #1515266: missing check of stopped
    parser in doContext() 'for' loop. */
-START_TEST(test_stop_parser_between_char_data_calls)
-{
-    /* The sample data must be big enough that there are two calls to
-       the character data handler from within the inner "for" loop of
-       the XML_TOK_DATA_CHARS case in doContent(), and the character
-       handler must stop the parser and clear the character data
-       handler.
-    */
-    const char *text = long_character_data_text;
+START_TEST(test_stop_parser_between_char_data_calls) {
+  /* The sample data must be big enough that there are two calls to
+     the character data handler from within the inner "for" loop of
+     the XML_TOK_DATA_CHARS case in doContent(), and the character
+     handler must stop the parser and clear the character data
+     handler.
+  */
+  const char *text = long_character_data_text;
 
-    XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
-    resumable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (XML_GetErrorCode(parser) != XML_ERROR_ABORTED)
-        xml_failure(parser);
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  resumable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_ABORTED)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Regression test for SF bug #1515266: missing check of stopped
    parser in doContext() 'for' loop. */
-START_TEST(test_suspend_parser_between_char_data_calls)
-{
-    /* The sample data must be big enough that there are two calls to
-       the character data handler from within the inner "for" loop of
-       the XML_TOK_DATA_CHARS case in doContent(), and the character
-       handler must stop the parser and clear the character data
-       handler.
-    */
-    const char *text = long_character_data_text;
-
-    XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
-    resumable = XML_TRUE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
-        xml_failure(parser);
-    /* Try parsing directly */
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Attempt to continue parse while suspended not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_SUSPENDED)
-        fail("Suspended parse not faulted with correct error");
+START_TEST(test_suspend_parser_between_char_data_calls) {
+  /* The sample data must be big enough that there are two calls to
+     the character data handler from within the inner "for" loop of
+     the XML_TOK_DATA_CHARS case in doContent(), and the character
+     handler must stop the parser and clear the character data
+     handler.
+  */
+  const char *text = long_character_data_text;
+
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  resumable = XML_TRUE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
+    xml_failure(g_parser);
+  /* Try parsing directly */
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Attempt to continue parse while suspended not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
+    fail("Suspended parse not faulted with correct error");
 }
 END_TEST
 
-
 static XML_Bool abortable = XML_FALSE;
 
 static void
-parser_stop_character_handler(void *UNUSED_P(userData),
-                              const XML_Char *UNUSED_P(s),
-                              int UNUSED_P(len))
-{
-    XML_StopParser(parser, resumable);
-    XML_SetCharacterDataHandler(parser, NULL);
-    if (!resumable) {
-        /* Check that aborting an aborted parser is faulted */
-        if (XML_StopParser(parser, XML_FALSE) != XML_STATUS_ERROR)
-            fail("Aborting aborted parser not faulted");
-        if (XML_GetErrorCode(parser) != XML_ERROR_FINISHED)
-            xml_failure(parser);
-    } else if (abortable) {
-        /* Check that aborting a suspended parser works */
-        if (XML_StopParser(parser, XML_FALSE) == XML_STATUS_ERROR)
-            xml_failure(parser);
-    } else {
-        /* Check that suspending a suspended parser works */
-        if (XML_StopParser(parser, XML_TRUE) != XML_STATUS_ERROR)
-            fail("Suspending suspended parser not faulted");
-        if (XML_GetErrorCode(parser) != XML_ERROR_SUSPENDED)
-            xml_failure(parser);
-    }
+parser_stop_character_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(userData);
+  UNUSED_P(s);
+  UNUSED_P(len);
+  XML_StopParser(g_parser, resumable);
+  XML_SetCharacterDataHandler(g_parser, NULL);
+  if (! resumable) {
+    /* Check that aborting an aborted parser is faulted */
+    if (XML_StopParser(g_parser, XML_FALSE) != XML_STATUS_ERROR)
+      fail("Aborting aborted parser not faulted");
+    if (XML_GetErrorCode(g_parser) != XML_ERROR_FINISHED)
+      xml_failure(g_parser);
+  } else if (abortable) {
+    /* Check that aborting a suspended parser works */
+    if (XML_StopParser(g_parser, XML_FALSE) == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+  } else {
+    /* Check that suspending a suspended parser works */
+    if (XML_StopParser(g_parser, XML_TRUE) != XML_STATUS_ERROR)
+      fail("Suspending suspended parser not faulted");
+    if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
+      xml_failure(g_parser);
+  }
 }
 
 /* Test repeated calls to XML_StopParser are handled correctly */
-START_TEST(test_repeated_stop_parser_between_char_data_calls)
-{
-    const char *text = long_character_data_text;
-
-    XML_SetCharacterDataHandler(parser, parser_stop_character_handler);
-    resumable = XML_FALSE;
-    abortable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Failed to double-stop parser");
-
-    XML_ParserReset(parser, NULL);
-    XML_SetCharacterDataHandler(parser, parser_stop_character_handler);
-    resumable = XML_TRUE;
-    abortable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_SUSPENDED)
-        fail("Failed to double-suspend parser");
-
-    XML_ParserReset(parser, NULL);
-    XML_SetCharacterDataHandler(parser, parser_stop_character_handler);
-    resumable = XML_TRUE;
-    abortable = XML_TRUE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Failed to suspend-abort parser");
-}
-END_TEST
-
-
-START_TEST(test_good_cdata_ascii)
-{
-    const char *text = "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
-    const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
-
-    CharData storage;
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    /* Add start and end handlers for coverage */
-    XML_SetStartCdataSectionHandler(parser, dummy_start_cdata_handler);
-    XML_SetEndCdataSectionHandler(parser, dummy_end_cdata_handler);
-
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-
-    /* Try again, this time with a default handler */
-    XML_ParserReset(parser, NULL);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
+START_TEST(test_repeated_stop_parser_between_char_data_calls) {
+  const char *text = long_character_data_text;
+
+  XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
+  resumable = XML_FALSE;
+  abortable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Failed to double-stop parser");
+
+  XML_ParserReset(g_parser, NULL);
+  XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
+  resumable = XML_TRUE;
+  abortable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    fail("Failed to double-suspend parser");
+
+  XML_ParserReset(g_parser, NULL);
+  XML_SetCharacterDataHandler(g_parser, parser_stop_character_handler);
+  resumable = XML_TRUE;
+  abortable = XML_TRUE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Failed to suspend-abort parser");
+}
+END_TEST
+
+START_TEST(test_good_cdata_ascii) {
+  const char *text = "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
+  const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
+
+  CharData storage;
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  /* Add start and end handlers for coverage */
+  XML_SetStartCdataSectionHandler(g_parser, dummy_start_cdata_handler);
+  XML_SetEndCdataSectionHandler(g_parser, dummy_end_cdata_handler);
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+
+  /* Try again, this time with a default handler */
+  XML_ParserReset(g_parser, NULL);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_good_cdata_utf16) {
+  /* Test data is:
+   *   <?xml version='1.0' encoding='utf-16'?>
+   *   <a><![CDATA[hello]]></a>
+   */
+  const char text[]
+      = "\0<\0?\0x\0m\0l\0"
+        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
+        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
+        "1\0"
+        "6\0'"
+        "\0?\0>\0\n"
+        "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>";
+  const XML_Char *expected = XCS("hello");
 
-START_TEST(test_good_cdata_utf16)
-{
-    /* Test data is:
-     *   <?xml version='1.0' encoding='utf-16'?>
-     *   <a><![CDATA[hello]]></a>
-     */
-    const char text[] =
-            "\0<\0?\0x\0m\0l\0"
-                " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
-                " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
-                "\0?\0>\0\n"
-            "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>";
-    const XML_Char *expected = XCS("hello");
-
-    CharData storage;
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
+  CharData storage;
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_good_cdata_utf16_le)
-{
-    /* Test data is:
-     *   <?xml version='1.0' encoding='utf-16'?>
-     *   <a><![CDATA[hello]]></a>
-     */
-    const char text[] =
-            "<\0?\0x\0m\0l\0"
-                " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
-                " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
-                "\0?\0>\0\n"
-            "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>\0";
-    const XML_Char *expected = XCS("hello");
-
-    CharData storage;
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
+START_TEST(test_good_cdata_utf16_le) {
+  /* Test data is:
+   *   <?xml version='1.0' encoding='utf-16'?>
+   *   <a><![CDATA[hello]]></a>
+   */
+  const char text[]
+      = "<\0?\0x\0m\0l\0"
+        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
+        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
+        "1\0"
+        "6\0'"
+        "\0?\0>\0\n"
+        "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0[\0h\0e\0l\0l\0o\0]\0]\0>\0<\0/\0a\0>\0";
+  const XML_Char *expected = XCS("hello");
+
+  CharData storage;
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
@@ -2365,20 +2184,20 @@ END_TEST
 /* 16 characters: handy macro to reduce visual clutter */
 #define A_TO_P_IN_UTF16 "\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P"
 
-START_TEST(test_long_cdata_utf16)
-{
-    /* Test data is:
-     * <?xlm version='1.0' encoding='utf-16'?>
-     * <a><![CDATA[
-     * ABCDEFGHIJKLMNOP
-     * ]]></a>
-     */
-    const char text[] =
-        "\0<\0?\0x\0m\0l\0 "
+START_TEST(test_long_cdata_utf16) {
+  /* Test data is:
+   * <?xlm version='1.0' encoding='utf-16'?>
+   * <a><![CDATA[
+   * ABCDEFGHIJKLMNOP
+   * ]]></a>
+   */
+  const char text[]
+      = "\0<\0?\0x\0m\0l\0 "
         "\0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0 "
         "\0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0\x31\0\x36\0'\0?\0>"
         "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
-        /* 64 characters per line */
+      /* 64 characters per line */
+      /* clang-format off */
         A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16
         A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16
         A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16
@@ -2396,8 +2215,10 @@ START_TEST(test_long_cdata_utf16)
         A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16
         A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16  A_TO_P_IN_UTF16
         A_TO_P_IN_UTF16
+        /* clang-format on */
         "\0]\0]\0>\0<\0/\0a\0>";
-    const XML_Char *expected =
+  const XML_Char *expected =
+      /* clang-format off */
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
@@ -2414,1398 +2235,1303 @@ START_TEST(test_long_cdata_utf16)
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
         XCS("ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP")
-        XCS("ABCDEFGHIJKLMNOP";)
-    CharData storage;
-    void *buffer;
+        XCS("ABCDEFGHIJKLMNOP");
+  /* clang-format on */
+  CharData storage;
+  void *buffer;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    buffer = XML_GetBuffer(parser, sizeof(text) - 1);
-    if (buffer == NULL)
-        fail("Could not allocate parse buffer");
-    memcpy(buffer, text, sizeof(text) - 1);
-    if (XML_ParseBuffer(parser,
-                        sizeof(text) - 1,
-                        XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  buffer = XML_GetBuffer(g_parser, sizeof(text) - 1);
+  if (buffer == NULL)
+    fail("Could not allocate parse buffer");
+  assert(buffer != NULL);
+  memcpy(buffer, text, sizeof(text) - 1);
+  if (XML_ParseBuffer(g_parser, sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test handling of multiple unit UTF-16 characters */
-START_TEST(test_multichar_cdata_utf16)
-{
-    /* Test data is:
-     *   <?xml version='1.0' encoding='utf-16'?>
-     *   <a><![CDATA[{MINIM}{CROTCHET}]]></a>
-     *
-     * where {MINIM} is U+1d15e (a minim or half-note)
-     *   UTF-16: 0xd834 0xdd5e
-     *   UTF-8:  0xf0 0x9d 0x85 0x9e
-     * and {CROTCHET} is U+1d15f (a crotchet or quarter-note)
-     *   UTF-16: 0xd834 0xdd5f
-     *   UTF-8:  0xf0 0x9d 0x85 0x9f
-     */
-    const char text[] =
-        "\0<\0?\0x\0m\0l\0"
-        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
-        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
-        "\0?\0>\0\n"
-        "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
-        "\xd8\x34\xdd\x5e\xd8\x34\xdd\x5f"
-        "\0]\0]\0>\0<\0/\0a\0>";
+START_TEST(test_multichar_cdata_utf16) {
+  /* Test data is:
+   *   <?xml version='1.0' encoding='utf-16'?>
+   *   <a><![CDATA[{MINIM}{CROTCHET}]]></a>
+   *
+   * where {MINIM} is U+1d15e (a minim or half-note)
+   *   UTF-16: 0xd834 0xdd5e
+   *   UTF-8:  0xf0 0x9d 0x85 0x9e
+   * and {CROTCHET} is U+1d15f (a crotchet or quarter-note)
+   *   UTF-16: 0xd834 0xdd5f
+   *   UTF-8:  0xf0 0x9d 0x85 0x9f
+   */
+  const char text[] = "\0<\0?\0x\0m\0l\0"
+                      " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
+                      " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
+                      "1\0"
+                      "6\0'"
+                      "\0?\0>\0\n"
+                      "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
+                      "\xd8\x34\xdd\x5e\xd8\x34\xdd\x5f"
+                      "\0]\0]\0>\0<\0/\0a\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\xd834\xdd5e\xd834\xdd5f");
+  const XML_Char *expected = XCS("\xd834\xdd5e\xd834\xdd5f");
 #else
-    const XML_Char *expected = XCS("\xf0\x9d\x85\x9e\xf0\x9d\x85\x9f");
+  const XML_Char *expected = XCS("\xf0\x9d\x85\x9e\xf0\x9d\x85\x9f");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text) - 1, XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test that an element name with a UTF-16 surrogate pair is rejected */
-START_TEST(test_utf16_bad_surrogate_pair)
-{
-    /* Test data is:
-     *   <?xml version='1.0' encoding='utf-16'?>
-     *   <a><![CDATA[{BADLINB}]]></a>
-     *
-     * where {BADLINB} is U+10000 (the first Linear B character)
-     * with the UTF-16 surrogate pair in the wrong order, i.e.
-     *   0xdc00 0xd800
-     */
-    const char text[] =
-        "\0<\0?\0x\0m\0l\0"
-        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
-        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
-        "\0?\0>\0\n"
-        "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
-        "\xdc\x00\xd8\x00"
-        "\0]\0]\0>\0<\0/\0a\0>";
+START_TEST(test_utf16_bad_surrogate_pair) {
+  /* Test data is:
+   *   <?xml version='1.0' encoding='utf-16'?>
+   *   <a><![CDATA[{BADLINB}]]></a>
+   *
+   * where {BADLINB} is U+10000 (the first Linear B character)
+   * with the UTF-16 surrogate pair in the wrong order, i.e.
+   *   0xdc00 0xd800
+   */
+  const char text[] = "\0<\0?\0x\0m\0l\0"
+                      " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
+                      " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
+                      "1\0"
+                      "6\0'"
+                      "\0?\0>\0\n"
+                      "\0<\0a\0>\0<\0!\0[\0C\0D\0A\0T\0A\0["
+                      "\xdc\x00\xd8\x00"
+                      "\0]\0]\0>\0<\0/\0a\0>";
+
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Reversed UTF-16 surrogate pair not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
+    xml_failure(g_parser);
+}
+END_TEST
+
+START_TEST(test_bad_cdata) {
+  struct CaseData {
+    const char *text;
+    enum XML_Error expectedError;
+  };
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text) - 1,
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Reversed UTF-16 surrogate pair not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
-        xml_failure(parser);
-}
-END_TEST
-
-
-START_TEST(test_bad_cdata)
-{
-    struct CaseData {
-        const char *text;
-        enum XML_Error expectedError;
-    };
-
-    struct CaseData cases[] = {
-        {"<a><", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><!", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![C", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![CD", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![CDA", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![CDAT", XML_ERROR_UNCLOSED_TOKEN},
-        {"<a><![CDATA", XML_ERROR_UNCLOSED_TOKEN},
-
-        {"<a><![CDATA[", XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {"<a><![CDATA[]", XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {"<a><![CDATA[]]", XML_ERROR_UNCLOSED_CDATA_SECTION},
-
-        {"<a><!<a/>", XML_ERROR_INVALID_TOKEN},
-        {"<a><![<a/>", XML_ERROR_UNCLOSED_TOKEN}, /* ?! */
-        {"<a><![C<a/>", XML_ERROR_UNCLOSED_TOKEN}, /* ?! */
-        {"<a><![CD<a/>", XML_ERROR_INVALID_TOKEN},
-        {"<a><![CDA<a/>", XML_ERROR_INVALID_TOKEN},
-        {"<a><![CDAT<a/>", XML_ERROR_INVALID_TOKEN},
-        {"<a><![CDATA<a/>", XML_ERROR_INVALID_TOKEN},
-
-        {"<a><![CDATA[<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {"<a><![CDATA[]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {"<a><![CDATA[]]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION}
-    };
-
-    size_t i = 0;
-    for (; i < sizeof(cases) / sizeof(struct CaseData); i++) {
-        const enum XML_Status actualStatus = _XML_Parse_SINGLE_BYTES(
-                parser, cases[i].text, (int)strlen(cases[i].text), XML_TRUE);
-        const enum XML_Error actualError = XML_GetErrorCode(parser);
-
-        assert(actualStatus == XML_STATUS_ERROR);
-
-        if (actualError != cases[i].expectedError) {
-            char message[100];
-            sprintf(message, "Expected error %d but got error %d for case %u: \"%s\"\n",
-                    cases[i].expectedError, actualError, (unsigned int)i + 1, cases[i].text);
-            fail(message);
-        }
+  struct CaseData cases[]
+      = {{"<a><", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><!", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![C", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![CD", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![CDA", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![CDAT", XML_ERROR_UNCLOSED_TOKEN},
+         {"<a><![CDATA", XML_ERROR_UNCLOSED_TOKEN},
 
-        XML_ParserReset(parser, NULL);
-    }
-}
-END_TEST
+         {"<a><![CDATA[", XML_ERROR_UNCLOSED_CDATA_SECTION},
+         {"<a><![CDATA[]", XML_ERROR_UNCLOSED_CDATA_SECTION},
+         {"<a><![CDATA[]]", XML_ERROR_UNCLOSED_CDATA_SECTION},
 
-/* Test failures in UTF-16 CDATA */
-START_TEST(test_bad_cdata_utf16)
-{
-    struct CaseData {
-        size_t text_bytes;
-        const char *text;
-        enum XML_Error expected_error;
-    };
-
-    const char prolog[] =
-        "\0<\0?\0x\0m\0l\0"
-        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
-        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0""1\0""6\0'"
-        "\0?\0>\0\n"
-        "\0<\0a\0>";
-    struct CaseData cases[] = {
-        {1, "\0", XML_ERROR_UNCLOSED_TOKEN},
-        {2, "\0<", XML_ERROR_UNCLOSED_TOKEN},
-        {3, "\0<\0", XML_ERROR_UNCLOSED_TOKEN},
-        {4, "\0<\0!", XML_ERROR_UNCLOSED_TOKEN},
-        {5, "\0<\0!\0", XML_ERROR_UNCLOSED_TOKEN},
-        {6, "\0<\0!\0[", XML_ERROR_UNCLOSED_TOKEN},
-        {7, "\0<\0!\0[\0", XML_ERROR_UNCLOSED_TOKEN},
-        {8, "\0<\0!\0[\0C", XML_ERROR_UNCLOSED_TOKEN},
-        {9, "\0<\0!\0[\0C\0", XML_ERROR_UNCLOSED_TOKEN},
-        {10, "\0<\0!\0[\0C\0D", XML_ERROR_UNCLOSED_TOKEN},
-        {11, "\0<\0!\0[\0C\0D\0", XML_ERROR_UNCLOSED_TOKEN},
-        {12, "\0<\0!\0[\0C\0D\0A", XML_ERROR_UNCLOSED_TOKEN},
-        {13, "\0<\0!\0[\0C\0D\0A\0", XML_ERROR_UNCLOSED_TOKEN},
-        {14, "\0<\0!\0[\0C\0D\0A\0T", XML_ERROR_UNCLOSED_TOKEN},
-        {15, "\0<\0!\0[\0C\0D\0A\0T\0", XML_ERROR_UNCLOSED_TOKEN},
-        {16, "\0<\0!\0[\0C\0D\0A\0T\0A", XML_ERROR_UNCLOSED_TOKEN},
-        {17, "\0<\0!\0[\0C\0D\0A\0T\0A\0", XML_ERROR_UNCLOSED_TOKEN},
-        {18, "\0<\0!\0[\0C\0D\0A\0T\0A\0[",
-         XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {19, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0",
-         XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {20, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z",
-         XML_ERROR_UNCLOSED_CDATA_SECTION},
-        /* Now add a four-byte UTF-16 character */
-        {21, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8",
-         XML_ERROR_UNCLOSED_CDATA_SECTION},
-        {22, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34",
-         XML_ERROR_PARTIAL_CHAR},
-        {23, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd",
-         XML_ERROR_PARTIAL_CHAR},
-        {24, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd\x5e",
-         XML_ERROR_UNCLOSED_CDATA_SECTION}
-    };
-    size_t i;
-
-    for (i = 0; i < sizeof(cases)/sizeof(struct CaseData); i++) {
-        enum XML_Status actual_status;
-        enum XML_Error actual_error;
-
-        if (_XML_Parse_SINGLE_BYTES(parser, prolog, (int)sizeof(prolog)-1,
-                                    XML_FALSE) == XML_STATUS_ERROR)
-            xml_failure(parser);
-        actual_status = _XML_Parse_SINGLE_BYTES(parser,
-                                                cases[i].text,
-                                                (int)cases[i].text_bytes,
-                                                XML_TRUE);
-        assert(actual_status == XML_STATUS_ERROR);
-        actual_error = XML_GetErrorCode(parser);
-        if (actual_error != cases[i].expected_error) {
-            char message[1024];
-
-            sprintf(message,
-                    "Expected error %d (%" XML_FMT_STR
-                    "), got %d (%" XML_FMT_STR ") for case %lu\n",
-                    cases[i].expected_error,
-                    XML_ErrorString(cases[i].expected_error),
-                    actual_error,
-                    XML_ErrorString(actual_error),
-                    (long unsigned)(i+1));
-            fail(message);
-        }
-        XML_ParserReset(parser, NULL);
+         {"<a><!<a/>", XML_ERROR_INVALID_TOKEN},
+         {"<a><![<a/>", XML_ERROR_UNCLOSED_TOKEN},  /* ?! */
+         {"<a><![C<a/>", XML_ERROR_UNCLOSED_TOKEN}, /* ?! */
+         {"<a><![CD<a/>", XML_ERROR_INVALID_TOKEN},
+         {"<a><![CDA<a/>", XML_ERROR_INVALID_TOKEN},
+         {"<a><![CDAT<a/>", XML_ERROR_INVALID_TOKEN},
+         {"<a><![CDATA<a/>", XML_ERROR_INVALID_TOKEN},
+
+         {"<a><![CDATA[<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
+         {"<a><![CDATA[]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION},
+         {"<a><![CDATA[]]<a/>", XML_ERROR_UNCLOSED_CDATA_SECTION}};
+
+  size_t i = 0;
+  for (; i < sizeof(cases) / sizeof(struct CaseData); i++) {
+    const enum XML_Status actualStatus = _XML_Parse_SINGLE_BYTES(
+        g_parser, cases[i].text, (int)strlen(cases[i].text), XML_TRUE);
+    const enum XML_Error actualError = XML_GetErrorCode(g_parser);
+
+    assert(actualStatus == XML_STATUS_ERROR);
+
+    if (actualError != cases[i].expectedError) {
+      char message[100];
+      sprintf(message,
+              "Expected error %d but got error %d for case %u: \"%s\"\n",
+              cases[i].expectedError, actualError, (unsigned int)i + 1,
+              cases[i].text);
+      fail(message);
     }
+
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
-static const char *long_cdata_text =
-    "<s><![CDATA["
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "012345678901234567890123456789012345678901234567890123456789"
-    "]]></s>";
+/* Test failures in UTF-16 CDATA */
+START_TEST(test_bad_cdata_utf16) {
+  struct CaseData {
+    size_t text_bytes;
+    const char *text;
+    enum XML_Error expected_error;
+  };
+
+  const char prolog[] = "\0<\0?\0x\0m\0l\0"
+                        " \0v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0"
+                        " \0e\0n\0c\0o\0d\0i\0n\0g\0=\0'\0u\0t\0f\0-\0"
+                        "1\0"
+                        "6\0'"
+                        "\0?\0>\0\n"
+                        "\0<\0a\0>";
+  struct CaseData cases[] = {
+      {1, "\0", XML_ERROR_UNCLOSED_TOKEN},
+      {2, "\0<", XML_ERROR_UNCLOSED_TOKEN},
+      {3, "\0<\0", XML_ERROR_UNCLOSED_TOKEN},
+      {4, "\0<\0!", XML_ERROR_UNCLOSED_TOKEN},
+      {5, "\0<\0!\0", XML_ERROR_UNCLOSED_TOKEN},
+      {6, "\0<\0!\0[", XML_ERROR_UNCLOSED_TOKEN},
+      {7, "\0<\0!\0[\0", XML_ERROR_UNCLOSED_TOKEN},
+      {8, "\0<\0!\0[\0C", XML_ERROR_UNCLOSED_TOKEN},
+      {9, "\0<\0!\0[\0C\0", XML_ERROR_UNCLOSED_TOKEN},
+      {10, "\0<\0!\0[\0C\0D", XML_ERROR_UNCLOSED_TOKEN},
+      {11, "\0<\0!\0[\0C\0D\0", XML_ERROR_UNCLOSED_TOKEN},
+      {12, "\0<\0!\0[\0C\0D\0A", XML_ERROR_UNCLOSED_TOKEN},
+      {13, "\0<\0!\0[\0C\0D\0A\0", XML_ERROR_UNCLOSED_TOKEN},
+      {14, "\0<\0!\0[\0C\0D\0A\0T", XML_ERROR_UNCLOSED_TOKEN},
+      {15, "\0<\0!\0[\0C\0D\0A\0T\0", XML_ERROR_UNCLOSED_TOKEN},
+      {16, "\0<\0!\0[\0C\0D\0A\0T\0A", XML_ERROR_UNCLOSED_TOKEN},
+      {17, "\0<\0!\0[\0C\0D\0A\0T\0A\0", XML_ERROR_UNCLOSED_TOKEN},
+      {18, "\0<\0!\0[\0C\0D\0A\0T\0A\0[", XML_ERROR_UNCLOSED_CDATA_SECTION},
+      {19, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0", XML_ERROR_UNCLOSED_CDATA_SECTION},
+      {20, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z", XML_ERROR_UNCLOSED_CDATA_SECTION},
+      /* Now add a four-byte UTF-16 character */
+      {21, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8",
+       XML_ERROR_UNCLOSED_CDATA_SECTION},
+      {22, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34", XML_ERROR_PARTIAL_CHAR},
+      {23, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd",
+       XML_ERROR_PARTIAL_CHAR},
+      {24, "\0<\0!\0[\0C\0D\0A\0T\0A\0[\0Z\xd8\x34\xdd\x5e",
+       XML_ERROR_UNCLOSED_CDATA_SECTION}};
+  size_t i;
+
+  for (i = 0; i < sizeof(cases) / sizeof(struct CaseData); i++) {
+    enum XML_Status actual_status;
+    enum XML_Error actual_error;
+
+    if (_XML_Parse_SINGLE_BYTES(g_parser, prolog, (int)sizeof(prolog) - 1,
+                                XML_FALSE)
+        == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+    actual_status = _XML_Parse_SINGLE_BYTES(g_parser, cases[i].text,
+                                            (int)cases[i].text_bytes, XML_TRUE);
+    assert(actual_status == XML_STATUS_ERROR);
+    actual_error = XML_GetErrorCode(g_parser);
+    if (actual_error != cases[i].expected_error) {
+      char message[1024];
+
+      sprintf(message,
+              "Expected error %d (%" XML_FMT_STR "), got %d (%" XML_FMT_STR
+              ") for case %lu\n",
+              cases[i].expected_error, XML_ErrorString(cases[i].expected_error),
+              actual_error, XML_ErrorString(actual_error),
+              (long unsigned)(i + 1));
+      fail(message);
+    }
+    XML_ParserReset(g_parser, NULL);
+  }
+}
+END_TEST
+
+static const char *long_cdata_text
+    = "<s><![CDATA["
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "012345678901234567890123456789012345678901234567890123456789"
+      "]]></s>";
 
 /* Test stopping the parser in cdata handler */
-START_TEST(test_stop_parser_between_cdata_calls)
-{
-    const char *text = long_cdata_text;
+START_TEST(test_stop_parser_between_cdata_calls) {
+  const char *text = long_cdata_text;
 
-    XML_SetCharacterDataHandler(parser,
-                                clearing_aborting_character_handler);
-    resumable = XML_FALSE;
-    expect_failure(text, XML_ERROR_ABORTED,
-                   "Parse not aborted in CDATA handler");
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  resumable = XML_FALSE;
+  expect_failure(text, XML_ERROR_ABORTED, "Parse not aborted in CDATA handler");
 }
 END_TEST
 
 /* Test suspending the parser in cdata handler */
-START_TEST(test_suspend_parser_between_cdata_calls)
-{
-    const char *text = long_cdata_text;
-    enum XML_Status result;
-
-    XML_SetCharacterDataHandler(parser,
-                                clearing_aborting_character_handler);
-    resumable = XML_TRUE;
-    result = _XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE);
-    if (result != XML_STATUS_SUSPENDED) {
-        if (result == XML_STATUS_ERROR)
-            xml_failure(parser);
-        fail("Parse not suspended in CDATA handler");
-    }
-    if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
-        xml_failure(parser);
+START_TEST(test_suspend_parser_between_cdata_calls) {
+  const char *text = long_cdata_text;
+  enum XML_Status result;
+
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  resumable = XML_TRUE;
+  result = _XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE);
+  if (result != XML_STATUS_SUSPENDED) {
+    if (result == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+    fail("Parse not suspended in CDATA handler");
+  }
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test memory allocation functions */
-START_TEST(test_memory_allocation)
-{
-    char *buffer = (char *)XML_MemMalloc(parser, 256);
-    char *p;
-
-    if (buffer == NULL) {
-        fail("Allocation failed");
+START_TEST(test_memory_allocation) {
+  char *buffer = (char *)XML_MemMalloc(g_parser, 256);
+  char *p;
+
+  if (buffer == NULL) {
+    fail("Allocation failed");
+  } else {
+    /* Try writing to memory; some OSes try to cheat! */
+    buffer[0] = 'T';
+    buffer[1] = 'E';
+    buffer[2] = 'S';
+    buffer[3] = 'T';
+    buffer[4] = '\0';
+    if (strcmp(buffer, "TEST") != 0) {
+      fail("Memory not writable");
     } else {
-        /* Try writing to memory; some OSes try to cheat! */
-        buffer[0] = 'T';
-        buffer[1] = 'E';
-        buffer[2] = 'S';
-        buffer[3] = 'T';
-        buffer[4] = '\0';
-        if (strcmp(buffer, "TEST") != 0) {
-            fail("Memory not writable");
-        } else {
-            p = (char *)XML_MemRealloc(parser, buffer, 512);
-            if (p == NULL) {
-                fail("Reallocation failed");
-            } else {
-                /* Write again, just to be sure */
-                buffer = p;
-                buffer[0] = 'V';
-                if (strcmp(buffer, "VEST") != 0) {
-                    fail("Reallocated memory not writable");
-                }
-            }
+      p = (char *)XML_MemRealloc(g_parser, buffer, 512);
+      if (p == NULL) {
+        fail("Reallocation failed");
+      } else {
+        /* Write again, just to be sure */
+        buffer = p;
+        buffer[0] = 'V';
+        if (strcmp(buffer, "VEST") != 0) {
+          fail("Reallocated memory not writable");
         }
-        XML_MemFree(parser, buffer);
+      }
     }
+    XML_MemFree(g_parser, buffer);
+  }
 }
 END_TEST
 
 static void XMLCALL
-record_default_handler(void *userData,
-                       const XML_Char *UNUSED_P(s),
-                       int UNUSED_P(len))
-{
-    CharData_AppendXMLChars((CharData *)userData, XCS("D"), 1);
+record_default_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(s);
+  UNUSED_P(len);
+  CharData_AppendXMLChars((CharData *)userData, XCS("D"), 1);
 }
 
 static void XMLCALL
-record_cdata_handler(void *userData,
-                     const XML_Char *UNUSED_P(s),
-                     int UNUSED_P(len))
-{
-    CharData_AppendXMLChars((CharData *)userData, XCS("C"), 1);
-    XML_DefaultCurrent(parser);
+record_cdata_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(s);
+  UNUSED_P(len);
+  CharData_AppendXMLChars((CharData *)userData, XCS("C"), 1);
+  XML_DefaultCurrent(g_parser);
 }
 
 static void XMLCALL
-record_cdata_nodefault_handler(void *userData,
-                     const XML_Char *UNUSED_P(s),
-                     int UNUSED_P(len))
-{
-    CharData_AppendXMLChars((CharData *)userData, XCS("c"), 1);
+record_cdata_nodefault_handler(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(s);
+  UNUSED_P(len);
+  CharData_AppendXMLChars((CharData *)userData, XCS("c"), 1);
 }
 
 static void XMLCALL
-record_skip_handler(void *userData,
-                    const XML_Char *UNUSED_P(entityName),
-                    int is_parameter_entity)
-{
-    CharData_AppendXMLChars((CharData *)userData,
-                            is_parameter_entity ? XCS("E") : XCS("e"), 1);
+record_skip_handler(void *userData, const XML_Char *entityName,
+                    int is_parameter_entity) {
+  UNUSED_P(entityName);
+  CharData_AppendXMLChars((CharData *)userData,
+                          is_parameter_entity ? XCS("E") : XCS("e"), 1);
 }
 
 /* Test XML_DefaultCurrent() passes handling on correctly */
-START_TEST(test_default_current)
-{
-    const char *text = "<doc>hell]</doc>";
-    const char *entity_text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY entity '&#37;'>\n"
-        "]>\n"
-        "<doc>&entity;</doc>";
-    CharData storage;
-
-    XML_SetDefaultHandler(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS("DCDCDCDCDCDD"));
-
-    /* Again, without the defaulting */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_nodefault_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS("DcccccD"));
-
-    /* Now with an internal entity to complicate matters */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, entity_text, (int)strlen(entity_text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* The default handler suppresses the entity */
-    CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDDD"));
-
-    /* Again, with a skip handler */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_handler);
-    XML_SetSkippedEntityHandler(parser, record_skip_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, entity_text, (int)strlen(entity_text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* The default handler suppresses the entity */
-    CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDeD"));
-
-    /* This time, allow the entity through */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandlerExpand(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, entity_text, (int)strlen(entity_text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDCDD"));
-
-    /* Finally, without passing the cdata to the default handler */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandlerExpand(parser, record_default_handler);
-    XML_SetCharacterDataHandler(parser, record_cdata_nodefault_handler);
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, entity_text, (int)strlen(entity_text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDcD"));
+START_TEST(test_default_current) {
+  const char *text = "<doc>hell]</doc>";
+  const char *entity_text = "<!DOCTYPE doc [\n"
+                            "<!ENTITY entity '&#37;'>\n"
+                            "]>\n"
+                            "<doc>&entity;</doc>";
+  CharData storage;
+
+  XML_SetDefaultHandler(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS("DCDCDCDCDCDD"));
+
+  /* Again, without the defaulting */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_nodefault_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS("DcccccD"));
+
+  /* Now with an internal entity to complicate matters */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
+                              XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* The default handler suppresses the entity */
+  CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDDD"));
+
+  /* Again, with a skip handler */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
+  XML_SetSkippedEntityHandler(g_parser, record_skip_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
+                              XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* The default handler suppresses the entity */
+  CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDeD"));
+
+  /* This time, allow the entity through */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandlerExpand(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
+                              XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDCDD"));
+
+  /* Finally, without passing the cdata to the default handler */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandlerExpand(g_parser, record_default_handler);
+  XML_SetCharacterDataHandler(g_parser, record_cdata_nodefault_handler);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, entity_text, (int)strlen(entity_text),
+                              XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS("DDDDDDDDDDDDDDDDDcD"));
 }
 END_TEST
 
 /* Test DTD element parsing code paths */
-START_TEST(test_dtd_elements)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc (chapter)>\n"
-        "<!ELEMENT chapter (#PCDATA)>\n"
-        "]>\n"
-        "<doc><chapter>Wombats are go</chapter></doc>";
+START_TEST(test_dtd_elements) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ELEMENT doc (chapter)>\n"
+                     "<!ELEMENT chapter (#PCDATA)>\n"
+                     "]>\n"
+                     "<doc><chapter>Wombats are go</chapter></doc>";
 
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test foreign DTD handling */
-START_TEST(test_set_foreign_dtd)
-{
-    const char *text1 =
-        "<?xml version='1.0' encoding='us-ascii'?>\n";
-    const char *text2 =
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
-
-    /* Check hash salt is passed through too */
-    XML_SetHashSalt(parser, 0x12345678);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    /* Add a default handler to exercise more code paths */
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-    if (XML_UseForeignDTD(parser, XML_TRUE) != XML_ERROR_NONE)
-        fail("Could not set foreign DTD");
-    if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    /* Ensure that trying to set the DTD after parsing has started
-     * is faulted, even if it's the same setting.
-     */
-    if (XML_UseForeignDTD(parser, XML_TRUE) !=
-        XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
-        fail("Failed to reject late foreign DTD setting");
-    /* Ditto for the hash salt */
-    if (XML_SetHashSalt(parser, 0x23456789))
-        fail("Failed to reject late hash salt change");
-
-    /* Now finish the parse */
-    if (_XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_set_foreign_dtd) {
+  const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n";
+  const char *text2 = "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
+
+  /* Check hash salt is passed through too */
+  XML_SetHashSalt(g_parser, 0x12345678);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  /* Add a default handler to exercise more code paths */
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+  if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
+    fail("Could not set foreign DTD");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  /* Ensure that trying to set the DTD after parsing has started
+   * is faulted, even if it's the same setting.
+   */
+  if (XML_UseForeignDTD(g_parser, XML_TRUE)
+      != XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
+    fail("Failed to reject late foreign DTD setting");
+  /* Ditto for the hash salt */
+  if (XML_SetHashSalt(g_parser, 0x23456789))
+    fail("Failed to reject late hash salt change");
+
+  /* Now finish the parse */
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test foreign DTD handling with a failing NotStandalone handler */
-START_TEST(test_foreign_dtd_not_standalone)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
+START_TEST(test_foreign_dtd_not_standalone) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetNotStandaloneHandler(parser, reject_not_standalone_handler);
-    if (XML_UseForeignDTD(parser, XML_TRUE) != XML_ERROR_NONE)
-        fail("Could not set foreign DTD");
-    expect_failure(text, XML_ERROR_NOT_STANDALONE,
-                   "NotStandalonehandler failed to reject");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetNotStandaloneHandler(g_parser, reject_not_standalone_handler);
+  if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
+    fail("Could not set foreign DTD");
+  expect_failure(text, XML_ERROR_NOT_STANDALONE,
+                 "NotStandalonehandler failed to reject");
 }
 END_TEST
 
 /* Test invalid character in a foreign DTD is faulted */
-START_TEST(test_invalid_foreign_dtd)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<doc>&entity;</doc>";
-    ExtFaults test_data = {
-        "$",
-        "Dollar not faulted",
-        NULL,
-        XML_ERROR_INVALID_TOKEN
-    };
+START_TEST(test_invalid_foreign_dtd) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<doc>&entity;</doc>";
+  ExtFaults test_data
+      = {"$", "Dollar not faulted", NULL, XML_ERROR_INVALID_TOKEN};
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    XML_UseForeignDTD(parser, XML_TRUE);
-    expect_failure(text,
-                   XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Bad DTD should not have been accepted");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  XML_UseForeignDTD(g_parser, XML_TRUE);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Bad DTD should not have been accepted");
 }
 END_TEST
 
 /* Test foreign DTD use with a doctype */
-START_TEST(test_foreign_dtd_with_doctype)
-{
-    const char *text1 =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc [<!ENTITY entity 'hello world'>]>\n";
-    const char *text2 =
-        "<doc>&entity;</doc>";
-    ExtTest test_data = {
-        "<!ELEMENT doc (#PCDATA)*>",
-        NULL,
-        NULL
-    };
-
-    /* Check hash salt is passed through too */
-    XML_SetHashSalt(parser, 0x12345678);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &test_data);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    /* Add a default handler to exercise more code paths */
-    XML_SetDefaultHandler(parser, dummy_default_handler);
-    if (XML_UseForeignDTD(parser, XML_TRUE) != XML_ERROR_NONE)
-        fail("Could not set foreign DTD");
-    if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    /* Ensure that trying to set the DTD after parsing has started
-     * is faulted, even if it's the same setting.
-     */
-    if (XML_UseForeignDTD(parser, XML_TRUE) !=
-        XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
-        fail("Failed to reject late foreign DTD setting");
-    /* Ditto for the hash salt */
-    if (XML_SetHashSalt(parser, 0x23456789))
-        fail("Failed to reject late hash salt change");
-
-    /* Now finish the parse */
-    if (_XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_foreign_dtd_with_doctype) {
+  const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                      "<!DOCTYPE doc [<!ENTITY entity 'hello world'>]>\n";
+  const char *text2 = "<doc>&entity;</doc>";
+  ExtTest test_data = {"<!ELEMENT doc (#PCDATA)*>", NULL, NULL};
+
+  /* Check hash salt is passed through too */
+  XML_SetHashSalt(g_parser, 0x12345678);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  /* Add a default handler to exercise more code paths */
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
+  if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
+    fail("Could not set foreign DTD");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  /* Ensure that trying to set the DTD after parsing has started
+   * is faulted, even if it's the same setting.
+   */
+  if (XML_UseForeignDTD(g_parser, XML_TRUE)
+      != XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING)
+    fail("Failed to reject late foreign DTD setting");
+  /* Ditto for the hash salt */
+  if (XML_SetHashSalt(g_parser, 0x23456789))
+    fail("Failed to reject late hash salt change");
+
+  /* Now finish the parse */
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test XML_UseForeignDTD with no external subset present */
 static int XMLCALL
-external_entity_null_loader(XML_Parser UNUSED_P(parser),
-                            const XML_Char *UNUSED_P(context),
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    return XML_STATUS_OK;
+external_entity_null_loader(XML_Parser parser, const XML_Char *context,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  UNUSED_P(parser);
+  UNUSED_P(context);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_foreign_dtd_without_external_subset)
-{
-    const char *text =
-        "<!DOCTYPE doc [<!ENTITY foo 'bar'>]>\n"
-        "<doc>&foo;</doc>";
+START_TEST(test_foreign_dtd_without_external_subset) {
+  const char *text = "<!DOCTYPE doc [<!ENTITY foo 'bar'>]>\n"
+                     "<doc>&foo;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, NULL);
-    XML_SetExternalEntityRefHandler(parser, external_entity_null_loader);
-    XML_UseForeignDTD(parser, XML_TRUE);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, NULL);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
+  XML_UseForeignDTD(g_parser, XML_TRUE);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_empty_foreign_dtd)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_empty_foreign_dtd) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<doc>&entity;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_null_loader);
-    XML_UseForeignDTD(parser, XML_TRUE);
-    expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
-                   "Undefined entity not faulted");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
+  XML_UseForeignDTD(g_parser, XML_TRUE);
+  expect_failure(text, XML_ERROR_UNDEFINED_ENTITY,
+                 "Undefined entity not faulted");
 }
 END_TEST
 
 /* Test XML Base is set and unset appropriately */
-START_TEST(test_set_base)
-{
-    const XML_Char *old_base;
-    const XML_Char *new_base = XCS("/local/file/name.xml");
+START_TEST(test_set_base) {
+  const XML_Char *old_base;
+  const XML_Char *new_base = XCS("/local/file/name.xml");
 
-    old_base = XML_GetBase(parser);
-    if (XML_SetBase(parser, new_base) != XML_STATUS_OK)
-        fail("Unable to set base");
-    if (xcstrcmp(XML_GetBase(parser), new_base) != 0)
-        fail("Base setting not correct");
-    if (XML_SetBase(parser, NULL) != XML_STATUS_OK)
-        fail("Unable to NULL base");
-    if (XML_GetBase(parser) != NULL)
-        fail("Base setting not nulled");
-    XML_SetBase(parser, old_base);
+  old_base = XML_GetBase(g_parser);
+  if (XML_SetBase(g_parser, new_base) != XML_STATUS_OK)
+    fail("Unable to set base");
+  if (xcstrcmp(XML_GetBase(g_parser), new_base) != 0)
+    fail("Base setting not correct");
+  if (XML_SetBase(g_parser, NULL) != XML_STATUS_OK)
+    fail("Unable to NULL base");
+  if (XML_GetBase(g_parser) != NULL)
+    fail("Base setting not nulled");
+  XML_SetBase(g_parser, old_base);
 }
 END_TEST
 
 /* Test attribute counts, indexing, etc */
 typedef struct attrInfo {
-    const XML_Char *name;
-    const XML_Char *value;
+  const XML_Char *name;
+  const XML_Char *value;
 } AttrInfo;
 
 typedef struct elementInfo {
-    const XML_Char *name;
-    int attr_count;
-    const XML_Char *id_name;
-    AttrInfo *attributes;
+  const XML_Char *name;
+  int attr_count;
+  const XML_Char *id_name;
+  AttrInfo *attributes;
 } ElementInfo;
 
 static void XMLCALL
-counting_start_element_handler(void *userData,
-                               const XML_Char *name,
-                               const XML_Char **atts)
-{
-    ElementInfo *info = (ElementInfo *)userData;
-    AttrInfo *attr;
-    int count, id, i;
-
-    while (info->name != NULL) {
-        if (!xcstrcmp(name, info->name))
-            break;
-        info++;
-    }
-    if (info->name == NULL)
-        fail("Element not recognised");
-    /* The attribute count is twice what you might expect.  It is a
-     * count of items in atts, an array which contains alternating
-     * attribute names and attribute values.  For the naive user this
-     * is possibly a little unexpected, but it is what the
-     * documentation in expat.h tells us to expect.
-     */
-    count = XML_GetSpecifiedAttributeCount(parser);
-    if (info->attr_count * 2 != count) {
-        fail("Not got expected attribute count");
-        return;
-    }
-    id = XML_GetIdAttributeIndex(parser);
-    if (id == -1 && info->id_name != NULL) {
-        fail("ID not present");
-        return;
-    }
-    if (id != -1 && xcstrcmp(atts[id], info->id_name)) {
-        fail("ID does not have the correct name");
-        return;
-    }
-    for (i = 0; i < info->attr_count; i++) {
-        attr = info->attributes;
-        while (attr->name != NULL) {
-            if (!xcstrcmp(atts[0], attr->name))
-                break;
-            attr++;
-        }
-        if (attr->name == NULL) {
-            fail("Attribute not recognised");
-            return;
-        }
-        if (xcstrcmp(atts[1], attr->value)) {
-            fail("Attribute has wrong value");
-            return;
-        }
-        /* Remember, two entries in atts per attribute (see above) */
-        atts += 2;
-    }
-}
-
-START_TEST(test_attributes)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc (tag)>\n"
-        "<!ATTLIST doc id ID #REQUIRED>\n"
-        "]>"
-        "<doc a='1' id='one' b='2'>"
-        "<tag c='3'/>"
-        "</doc>";
-    AttrInfo doc_info[] = {
-        { XCS("a"),  XCS("1") },
-        { XCS("b"),  XCS("2") },
-        { XCS("id"), XCS("one") },
-        { NULL, NULL }
-    };
-    AttrInfo tag_info[] = {
-        { XCS("c"),  XCS("3") },
-        { NULL, NULL }
-    };
-    ElementInfo info[] = {
-        { XCS("doc"), 3, XCS("id"), NULL },
-        { XCS("tag"), 1, NULL, NULL },
-        { NULL, 0, NULL, NULL }
-    };
-    info[0].attributes = doc_info;
-    info[1].attributes = tag_info;
-
-    XML_SetStartElementHandler(parser, counting_start_element_handler);
-    XML_SetUserData(parser, info);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+counting_start_element_handler(void *userData, const XML_Char *name,
+                               const XML_Char **atts) {
+  ElementInfo *info = (ElementInfo *)userData;
+  AttrInfo *attr;
+  int count, id, i;
+
+  while (info->name != NULL) {
+    if (! xcstrcmp(name, info->name))
+      break;
+    info++;
+  }
+  if (info->name == NULL)
+    fail("Element not recognised");
+  /* The attribute count is twice what you might expect.  It is a
+   * count of items in atts, an array which contains alternating
+   * attribute names and attribute values.  For the naive user this
+   * is possibly a little unexpected, but it is what the
+   * documentation in expat.h tells us to expect.
+   */
+  count = XML_GetSpecifiedAttributeCount(g_parser);
+  if (info->attr_count * 2 != count) {
+    fail("Not got expected attribute count");
+    return;
+  }
+  id = XML_GetIdAttributeIndex(g_parser);
+  if (id == -1 && info->id_name != NULL) {
+    fail("ID not present");
+    return;
+  }
+  if (id != -1 && xcstrcmp(atts[id], info->id_name)) {
+    fail("ID does not have the correct name");
+    return;
+  }
+  for (i = 0; i < info->attr_count; i++) {
+    attr = info->attributes;
+    while (attr->name != NULL) {
+      if (! xcstrcmp(atts[0], attr->name))
+        break;
+      attr++;
+    }
+    if (attr->name == NULL) {
+      fail("Attribute not recognised");
+      return;
+    }
+    if (xcstrcmp(atts[1], attr->value)) {
+      fail("Attribute has wrong value");
+      return;
+    }
+    /* Remember, two entries in atts per attribute (see above) */
+    atts += 2;
+  }
+}
+
+START_TEST(test_attributes) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ELEMENT doc (tag)>\n"
+                     "<!ATTLIST doc id ID #REQUIRED>\n"
+                     "]>"
+                     "<doc a='1' id='one' b='2'>"
+                     "<tag c='3'/>"
+                     "</doc>";
+  AttrInfo doc_info[] = {{XCS("a"), XCS("1")},
+                         {XCS("b"), XCS("2")},
+                         {XCS("id"), XCS("one")},
+                         {NULL, NULL}};
+  AttrInfo tag_info[] = {{XCS("c"), XCS("3")}, {NULL, NULL}};
+  ElementInfo info[] = {{XCS("doc"), 3, XCS("id"), NULL},
+                        {XCS("tag"), 1, NULL, NULL},
+                        {NULL, 0, NULL, NULL}};
+  info[0].attributes = doc_info;
+  info[1].attributes = tag_info;
+
+  XML_SetStartElementHandler(g_parser, counting_start_element_handler);
+  XML_SetUserData(g_parser, info);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test reset works correctly in the middle of processing an internal
  * entity.  Exercises some obscure code in XML_ParserReset().
  */
-START_TEST(test_reset_in_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY wombat 'wom'>\n"
-        "<!ENTITY entity 'hi &wom; there'>\n"
-        "]>\n"
-        "<doc>&entity;</doc>";
-    XML_ParsingStatus status;
-
-    resumable = XML_TRUE;
-    XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    XML_GetParsingStatus(parser, &status);
-    if (status.parsing != XML_SUSPENDED)
-        fail("Parsing status not SUSPENDED");
-    XML_ParserReset(parser, NULL);
-    XML_GetParsingStatus(parser, &status);
-    if (status.parsing != XML_INITIALIZED)
-        fail("Parsing status doesn't reset to INITIALIZED");
+START_TEST(test_reset_in_entity) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY wombat 'wom'>\n"
+                     "<!ENTITY entity 'hi &wom; there'>\n"
+                     "]>\n"
+                     "<doc>&entity;</doc>";
+  XML_ParsingStatus status;
+
+  resumable = XML_TRUE;
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  XML_GetParsingStatus(g_parser, &status);
+  if (status.parsing != XML_SUSPENDED)
+    fail("Parsing status not SUSPENDED");
+  XML_ParserReset(g_parser, NULL);
+  XML_GetParsingStatus(g_parser, &status);
+  if (status.parsing != XML_INITIALIZED)
+    fail("Parsing status doesn't reset to INITIALIZED");
 }
 END_TEST
 
 /* Test that resume correctly passes through parse errors */
-START_TEST(test_resume_invalid_parse)
-{
-    const char *text = "<doc>Hello</doc"; /* Missing closing wedge */
+START_TEST(test_resume_invalid_parse) {
+  const char *text = "<doc>Hello</doc"; /* Missing closing wedge */
 
-    resumable = XML_TRUE;
-    XML_SetCharacterDataHandler(parser,
-                                clearing_aborting_character_handler);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (XML_ResumeParser(parser) == XML_STATUS_OK)
-        fail("Resumed invalid parse not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_UNCLOSED_TOKEN)
-        fail("Invalid parse not correctly faulted");
+  resumable = XML_TRUE;
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (XML_ResumeParser(g_parser) == XML_STATUS_OK)
+    fail("Resumed invalid parse not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_UNCLOSED_TOKEN)
+    fail("Invalid parse not correctly faulted");
 }
 END_TEST
 
 /* Test that re-suspended parses are correctly passed through */
-START_TEST(test_resume_resuspended)
-{
-    const char *text = "<doc>Hello<meep/>world</doc>";
-
-    resumable = XML_TRUE;
-    XML_SetCharacterDataHandler(parser,
-                                clearing_aborting_character_handler);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    resumable = XML_TRUE;
-    XML_SetCharacterDataHandler(parser,
-                                clearing_aborting_character_handler);
-    if (XML_ResumeParser(parser) != XML_STATUS_SUSPENDED)
-        fail("Resumption not suspended");
-    /* This one should succeed and finish up */
-    if (XML_ResumeParser(parser) != XML_STATUS_OK)
-        xml_failure(parser);
+START_TEST(test_resume_resuspended) {
+  const char *text = "<doc>Hello<meep/>world</doc>";
+
+  resumable = XML_TRUE;
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  resumable = XML_TRUE;
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  if (XML_ResumeParser(g_parser) != XML_STATUS_SUSPENDED)
+    fail("Resumption not suspended");
+  /* This one should succeed and finish up */
+  if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that CDATA shows up correctly through a default handler */
-START_TEST(test_cdata_default)
-{
-    const char *text = "<doc><![CDATA[Hello\nworld]]></doc>";
-    const XML_Char *expected = XCS("<doc><![CDATA[Hello\nworld]]></doc>");
-    CharData storage;
+START_TEST(test_cdata_default) {
+  const char *text = "<doc><![CDATA[Hello\nworld]]></doc>";
+  const XML_Char *expected = XCS("<doc><![CDATA[Hello\nworld]]></doc>");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetDefaultHandler(parser, accumulate_characters);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test resetting a subordinate parser does exactly nothing */
 static int XMLCALL
-external_entity_resetter(XML_Parser parser,
-                         const XML_Char *context,
-                         const XML_Char *UNUSED_P(base),
-                         const XML_Char *UNUSED_P(systemId),
-                         const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<!ELEMENT doc (#PCDATA)*>";
-    XML_Parser ext_parser;
-    XML_ParsingStatus status;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_GetParsingStatus(ext_parser, &status);
-    if (status.parsing != XML_INITIALIZED) {
-        fail("Parsing status is not INITIALIZED");
-        return XML_STATUS_ERROR;
-    }
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(parser);
-        return XML_STATUS_ERROR;
-    }
-    XML_GetParsingStatus(ext_parser, &status);
-    if (status.parsing != XML_FINISHED) {
-        fail("Parsing status is not FINISHED");
-        return XML_STATUS_ERROR;
-    }
-    /* Check we can't parse here */
-    if (XML_Parse(ext_parser, text, (int)strlen(text),
-                  XML_TRUE) != XML_STATUS_ERROR)
-        fail("Parsing when finished not faulted");
-    if (XML_GetErrorCode(ext_parser) != XML_ERROR_FINISHED)
-        fail("Parsing when finished faulted with wrong code");
-    XML_ParserReset(ext_parser, NULL);
-    XML_GetParsingStatus(ext_parser, &status);
-    if (status.parsing != XML_FINISHED) {
-        fail("Parsing status not still FINISHED");
-        return XML_STATUS_ERROR;
-    }
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
+external_entity_resetter(XML_Parser parser, const XML_Char *context,
+                         const XML_Char *base, const XML_Char *systemId,
+                         const XML_Char *publicId) {
+  const char *text = "<!ELEMENT doc (#PCDATA)*>";
+  XML_Parser ext_parser;
+  XML_ParsingStatus status;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_GetParsingStatus(ext_parser, &status);
+  if (status.parsing != XML_INITIALIZED) {
+    fail("Parsing status is not INITIALIZED");
+    return XML_STATUS_ERROR;
+  }
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(parser);
+    return XML_STATUS_ERROR;
+  }
+  XML_GetParsingStatus(ext_parser, &status);
+  if (status.parsing != XML_FINISHED) {
+    fail("Parsing status is not FINISHED");
+    return XML_STATUS_ERROR;
+  }
+  /* Check we can't parse here */
+  if (XML_Parse(ext_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Parsing when finished not faulted");
+  if (XML_GetErrorCode(ext_parser) != XML_ERROR_FINISHED)
+    fail("Parsing when finished faulted with wrong code");
+  XML_ParserReset(ext_parser, NULL);
+  XML_GetParsingStatus(ext_parser, &status);
+  if (status.parsing != XML_FINISHED) {
+    fail("Parsing status not still FINISHED");
+    return XML_STATUS_ERROR;
+  }
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_subordinate_reset)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_subordinate_reset) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_resetter);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_resetter);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
 /* Test suspending a subordinate parser */
 
 static void XMLCALL
-entity_suspending_decl_handler(void *userData,
-                               const XML_Char *UNUSED_P(name),
-                               XML_Content *model)
-{
-    XML_Parser ext_parser = (XML_Parser)userData;
+entity_suspending_decl_handler(void *userData, const XML_Char *name,
+                               XML_Content *model) {
+  XML_Parser ext_parser = (XML_Parser)userData;
 
-    if (XML_StopParser(ext_parser, XML_TRUE) != XML_STATUS_ERROR)
-        fail("Attempting to suspend a subordinate parser not faulted");
-    if (XML_GetErrorCode(ext_parser) != XML_ERROR_SUSPEND_PE)
-        fail("Suspending subordinate parser get wrong code");
-    XML_SetElementDeclHandler(ext_parser, NULL);
-    XML_FreeContentModel(parser, model);
+  UNUSED_P(name);
+  if (XML_StopParser(ext_parser, XML_TRUE) != XML_STATUS_ERROR)
+    fail("Attempting to suspend a subordinate parser not faulted");
+  if (XML_GetErrorCode(ext_parser) != XML_ERROR_SUSPEND_PE)
+    fail("Suspending subordinate parser get wrong code");
+  XML_SetElementDeclHandler(ext_parser, NULL);
+  XML_FreeContentModel(g_parser, model);
 }
 
 static int XMLCALL
-external_entity_suspender(XML_Parser parser,
-                          const XML_Char *context,
-                          const XML_Char *UNUSED_P(base),
-                          const XML_Char *UNUSED_P(systemId),
-                          const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<!ELEMENT doc (#PCDATA)*>";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetElementDeclHandler(ext_parser, entity_suspending_decl_handler);
-    XML_SetUserData(ext_parser, ext_parser);
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(ext_parser);
-        return XML_STATUS_ERROR;
-    }
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
+external_entity_suspender(XML_Parser parser, const XML_Char *context,
+                          const XML_Char *base, const XML_Char *systemId,
+                          const XML_Char *publicId) {
+  const char *text = "<!ELEMENT doc (#PCDATA)*>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetElementDeclHandler(ext_parser, entity_suspending_decl_handler);
+  XML_SetUserData(ext_parser, ext_parser);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(ext_parser);
+    return XML_STATUS_ERROR;
+  }
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_subordinate_suspend)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_subordinate_suspend) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_suspender);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_suspender);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test suspending a subordinate parser from an XML declaration */
 /* Increases code coverage of the tests */
 static void XMLCALL
-entity_suspending_xdecl_handler(void *userData,
-                                const XML_Char *UNUSED_P(version),
-                                const XML_Char *UNUSED_P(encoding),
-                                int UNUSED_P(standalone))
-{
-    XML_Parser ext_parser = (XML_Parser)userData;
+entity_suspending_xdecl_handler(void *userData, const XML_Char *version,
+                                const XML_Char *encoding, int standalone) {
+  XML_Parser ext_parser = (XML_Parser)userData;
 
-    XML_StopParser(ext_parser, resumable);
-    XML_SetXmlDeclHandler(ext_parser, NULL);
+  UNUSED_P(version);
+  UNUSED_P(encoding);
+  UNUSED_P(standalone);
+  XML_StopParser(ext_parser, resumable);
+  XML_SetXmlDeclHandler(ext_parser, NULL);
 }
 
 static int XMLCALL
-external_entity_suspend_xmldecl(XML_Parser parser,
-                                const XML_Char *context,
-                                const XML_Char *UNUSED_P(base),
-                                const XML_Char *UNUSED_P(systemId),
-                                const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<?xml version='1.0' encoding='us-ascii'?>";
-    XML_Parser ext_parser;
-    XML_ParsingStatus status;
-    enum XML_Status rc;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
-    XML_SetUserData(ext_parser, ext_parser);
-    rc = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE);
-    XML_GetParsingStatus(ext_parser, &status);
-    if (resumable) {
-        if (rc == XML_STATUS_ERROR)
-            xml_failure(ext_parser);
-        if (status.parsing != XML_SUSPENDED)
-            fail("Ext Parsing status not SUSPENDED");
-    } else {
-        if (rc != XML_STATUS_ERROR)
-            fail("Ext parsing not aborted");
-        if (XML_GetErrorCode(ext_parser) != XML_ERROR_ABORTED)
-            xml_failure(ext_parser);
-        if (status.parsing != XML_FINISHED)
-            fail("Ext Parsing status not FINISHED");
-    }
+external_entity_suspend_xmldecl(XML_Parser parser, const XML_Char *context,
+                                const XML_Char *base, const XML_Char *systemId,
+                                const XML_Char *publicId) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>";
+  XML_Parser ext_parser;
+  XML_ParsingStatus status;
+  enum XML_Status rc;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
+  XML_SetUserData(ext_parser, ext_parser);
+  rc = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE);
+  XML_GetParsingStatus(ext_parser, &status);
+  if (resumable) {
+    if (rc == XML_STATUS_ERROR)
+      xml_failure(ext_parser);
+    if (status.parsing != XML_SUSPENDED)
+      fail("Ext Parsing status not SUSPENDED");
+  } else {
+    if (rc != XML_STATUS_ERROR)
+      fail("Ext parsing not aborted");
+    if (XML_GetErrorCode(ext_parser) != XML_ERROR_ABORTED)
+      xml_failure(ext_parser);
+    if (status.parsing != XML_FINISHED)
+      fail("Ext Parsing status not FINISHED");
+  }
 
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_subordinate_xdecl_suspend)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_subordinate_xdecl_suspend) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ENTITY entity SYSTEM 'http://example.org/dummy.ent'>\n"
         "]>\n"
         "<doc>&entity;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_suspend_xmldecl);
-    resumable = XML_TRUE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_suspend_xmldecl);
+  resumable = XML_TRUE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_subordinate_xdecl_abort)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_subordinate_xdecl_abort) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ENTITY entity SYSTEM 'http://example.org/dummy.ent'>\n"
         "]>\n"
         "<doc>&entity;</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_suspend_xmldecl);
-    resumable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_suspend_xmldecl);
+  resumable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test external entity fault handling with suspension */
 static int XMLCALL
-external_entity_suspending_faulter(XML_Parser parser,
-                                   const XML_Char *context,
-                                   const XML_Char *UNUSED_P(base),
-                                   const XML_Char *UNUSED_P(systemId),
-                                   const XML_Char *UNUSED_P(publicId))
-{
-    XML_Parser ext_parser;
-    ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
-    void *buffer;
-    int parse_len = (int)strlen(fault->parse_text);
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
-    XML_SetUserData(ext_parser, ext_parser);
-    resumable = XML_TRUE;
-    buffer = XML_GetBuffer(ext_parser, parse_len);
-    if (buffer == NULL)
-        fail("Could not allocate parse buffer");
-    memcpy(buffer, fault->parse_text, parse_len);
-    if (XML_ParseBuffer(ext_parser, parse_len,
-                        XML_FALSE) != XML_STATUS_SUSPENDED)
-        fail("XML declaration did not suspend");
-    if (XML_ResumeParser(ext_parser) != XML_STATUS_OK)
-        xml_failure(ext_parser);
-    if (XML_ParseBuffer(ext_parser, 0, XML_TRUE) != XML_STATUS_ERROR)
-        fail(fault->fail_text);
-    if (XML_GetErrorCode(ext_parser) != fault->error)
-        xml_failure(ext_parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_ERROR;
-}
-
-START_TEST(test_ext_entity_invalid_suspended_parse)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtFaults faults[] = {
-        {
-            "<?xml version='1.0' encoding='us-ascii'?><",
-            "Incomplete element declaration not faulted",
-            NULL,
-            XML_ERROR_UNCLOSED_TOKEN
-        },
-        {
-            /* First two bytes of a three-byte char */
-            "<?xml version='1.0' encoding='utf-8'?>\xe2\x82",
-            "Incomplete character not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        { NULL, NULL, NULL, XML_ERROR_NONE }
-    };
-    ExtFaults *fault;
-
-    for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser,
-                                        external_entity_suspending_faulter);
-        XML_SetUserData(parser, fault);
-        expect_failure(text,
-                       XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                       "Parser did not report external entity error");
-        XML_ParserReset(parser, NULL);
-    }
+external_entity_suspending_faulter(XML_Parser parser, const XML_Char *context,
+                                   const XML_Char *base,
+                                   const XML_Char *systemId,
+                                   const XML_Char *publicId) {
+  XML_Parser ext_parser;
+  ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
+  void *buffer;
+  int parse_len = (int)strlen(fault->parse_text);
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
+  XML_SetUserData(ext_parser, ext_parser);
+  resumable = XML_TRUE;
+  buffer = XML_GetBuffer(ext_parser, parse_len);
+  if (buffer == NULL)
+    fail("Could not allocate parse buffer");
+  assert(buffer != NULL);
+  memcpy(buffer, fault->parse_text, parse_len);
+  if (XML_ParseBuffer(ext_parser, parse_len, XML_FALSE) != XML_STATUS_SUSPENDED)
+    fail("XML declaration did not suspend");
+  if (XML_ResumeParser(ext_parser) != XML_STATUS_OK)
+    xml_failure(ext_parser);
+  if (XML_ParseBuffer(ext_parser, 0, XML_TRUE) != XML_STATUS_ERROR)
+    fail(fault->fail_text);
+  if (XML_GetErrorCode(ext_parser) != fault->error)
+    xml_failure(ext_parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_ERROR;
+}
+
+START_TEST(test_ext_entity_invalid_suspended_parse) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtFaults faults[]
+      = {{"<?xml version='1.0' encoding='us-ascii'?><",
+          "Incomplete element declaration not faulted", NULL,
+          XML_ERROR_UNCLOSED_TOKEN},
+         {/* First two bytes of a three-byte char */
+          "<?xml version='1.0' encoding='utf-8'?>\xe2\x82",
+          "Incomplete character not faulted", NULL, XML_ERROR_PARTIAL_CHAR},
+         {NULL, NULL, NULL, XML_ERROR_NONE}};
+  ExtFaults *fault;
+
+  for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser,
+                                    external_entity_suspending_faulter);
+    XML_SetUserData(g_parser, fault);
+    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                   "Parser did not report external entity error");
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
-
-
 /* Test setting an explicit encoding */
-START_TEST(test_explicit_encoding)
-{
-    const char *text1 = "<doc>Hello ";
-    const char *text2 = " World</doc>";
-
-    /* Just check that we can set the encoding to NULL before starting */
-    if (XML_SetEncoding(parser, NULL) != XML_STATUS_OK)
-        fail("Failed to initialise encoding to NULL");
-    /* Say we are UTF-8 */
-    if (XML_SetEncoding(parser, XCS("utf-8")) != XML_STATUS_OK)
-        fail("Failed to set explicit encoding");
-    if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* Try to switch encodings mid-parse */
-    if (XML_SetEncoding(parser, XCS("us-ascii")) != XML_STATUS_ERROR)
-        fail("Allowed encoding change");
-    if (_XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* Try now the parse is over */
-    if (XML_SetEncoding(parser, NULL) != XML_STATUS_OK)
-        fail("Failed to unset encoding");
+START_TEST(test_explicit_encoding) {
+  const char *text1 = "<doc>Hello ";
+  const char *text2 = " World</doc>";
+
+  /* Just check that we can set the encoding to NULL before starting */
+  if (XML_SetEncoding(g_parser, NULL) != XML_STATUS_OK)
+    fail("Failed to initialise encoding to NULL");
+  /* Say we are UTF-8 */
+  if (XML_SetEncoding(g_parser, XCS("utf-8")) != XML_STATUS_OK)
+    fail("Failed to set explicit encoding");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* Try to switch encodings mid-parse */
+  if (XML_SetEncoding(g_parser, XCS("us-ascii")) != XML_STATUS_ERROR)
+    fail("Allowed encoding change");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* Try now the parse is over */
+  if (XML_SetEncoding(g_parser, NULL) != XML_STATUS_OK)
+    fail("Failed to unset encoding");
 }
 END_TEST
 
-
 /* Test handling of trailing CR (rather than newline) */
 static void XMLCALL
-cr_cdata_handler(void *userData, const XML_Char *s, int len)
-{
-    int *pfound = (int *)userData;
-
-    /* Internal processing turns the CR into a newline for the
-     * character data handler, but not for the default handler
-     */
-    if (len == 1 && (*s == XCS('\n') || *s == XCS('\r')))
-        *pfound = 1;
-}
-
-START_TEST(test_trailing_cr)
-{
-    const char *text = "<doc>\r";
-    int found_cr;
-
-    /* Try with a character handler, for code coverage */
-    XML_SetCharacterDataHandler(parser, cr_cdata_handler);
-    XML_SetUserData(parser, &found_cr);
-    found_cr = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Failed to fault unclosed doc");
-    if (found_cr == 0)
-        fail("Did not catch the carriage return");
-    XML_ParserReset(parser, NULL);
-
-    /* Now with a default handler instead */
-    XML_SetDefaultHandler(parser, cr_cdata_handler);
-    XML_SetUserData(parser, &found_cr);
-    found_cr = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Failed to fault unclosed doc");
-    if (found_cr == 0)
-        fail("Did not catch default carriage return");
+cr_cdata_handler(void *userData, const XML_Char *s, int len) {
+  int *pfound = (int *)userData;
+
+  /* Internal processing turns the CR into a newline for the
+   * character data handler, but not for the default handler
+   */
+  if (len == 1 && (*s == XCS('\n') || *s == XCS('\r')))
+    *pfound = 1;
+}
+
+START_TEST(test_trailing_cr) {
+  const char *text = "<doc>\r";
+  int found_cr;
+
+  /* Try with a character handler, for code coverage */
+  XML_SetCharacterDataHandler(g_parser, cr_cdata_handler);
+  XML_SetUserData(g_parser, &found_cr);
+  found_cr = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Failed to fault unclosed doc");
+  if (found_cr == 0)
+    fail("Did not catch the carriage return");
+  XML_ParserReset(g_parser, NULL);
+
+  /* Now with a default handler instead */
+  XML_SetDefaultHandler(g_parser, cr_cdata_handler);
+  XML_SetUserData(g_parser, &found_cr);
+  found_cr = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Failed to fault unclosed doc");
+  if (found_cr == 0)
+    fail("Did not catch default carriage return");
 }
 END_TEST
 
 /* Test trailing CR in an external entity parse */
 static int XMLCALL
-external_entity_cr_catcher(XML_Parser parser,
-                           const XML_Char *context,
-                           const XML_Char *UNUSED_P(base),
-                           const XML_Char *UNUSED_P(systemId),
-                           const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "\r";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetCharacterDataHandler(ext_parser, cr_cdata_handler);
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(ext_parser);
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
+external_entity_cr_catcher(XML_Parser parser, const XML_Char *context,
+                           const XML_Char *base, const XML_Char *systemId,
+                           const XML_Char *publicId) {
+  const char *text = "\r";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetCharacterDataHandler(ext_parser, cr_cdata_handler);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(ext_parser);
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
 static int XMLCALL
-external_entity_bad_cr_catcher(XML_Parser parser,
-                               const XML_Char *context,
-                               const XML_Char *UNUSED_P(base),
-                               const XML_Char *UNUSED_P(systemId),
-                               const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<tag>\r";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetCharacterDataHandler(ext_parser, cr_cdata_handler);
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Async entity error not caught");
-    if (XML_GetErrorCode(ext_parser) != XML_ERROR_ASYNC_ENTITY)
-        xml_failure(ext_parser);
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ext_entity_trailing_cr)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    int found_cr;
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_cr_catcher);
-    XML_SetUserData(parser, &found_cr);
-    found_cr = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
-    if (found_cr == 0)
-        fail("No carriage return found");
-    XML_ParserReset(parser, NULL);
-
-    /* Try again with a different trailing CR */
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_bad_cr_catcher);
-    XML_SetUserData(parser, &found_cr);
-    found_cr = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
-    if (found_cr == 0)
-        fail("No carriage return found");
+external_entity_bad_cr_catcher(XML_Parser parser, const XML_Char *context,
+                               const XML_Char *base, const XML_Char *systemId,
+                               const XML_Char *publicId) {
+  const char *text = "<tag>\r";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetCharacterDataHandler(ext_parser, cr_cdata_handler);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Async entity error not caught");
+  if (XML_GetErrorCode(ext_parser) != XML_ERROR_ASYNC_ENTITY)
+    xml_failure(ext_parser);
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ext_entity_trailing_cr) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  int found_cr;
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_cr_catcher);
+  XML_SetUserData(g_parser, &found_cr);
+  found_cr = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_OK)
+    xml_failure(g_parser);
+  if (found_cr == 0)
+    fail("No carriage return found");
+  XML_ParserReset(g_parser, NULL);
+
+  /* Try again with a different trailing CR */
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_bad_cr_catcher);
+  XML_SetUserData(g_parser, &found_cr);
+  found_cr = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_OK)
+    xml_failure(g_parser);
+  if (found_cr == 0)
+    fail("No carriage return found");
 }
 END_TEST
 
 /* Test handling of trailing square bracket */
 static void XMLCALL
-rsqb_handler(void *userData, const XML_Char *s, int len)
-{
-    int *pfound = (int *)userData;
-
-    if (len == 1 && *s == XCS(']'))
-        *pfound = 1;
-}
-
-START_TEST(test_trailing_rsqb)
-{
-    const char *text8 = "<doc>]";
-    const char text16[] = "\xFF\xFE<\000d\000o\000c\000>\000]\000";
-    int found_rsqb;
-    int text8_len = (int)strlen(text8);
-
-    XML_SetCharacterDataHandler(parser, rsqb_handler);
-    XML_SetUserData(parser, &found_rsqb);
-    found_rsqb = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text8, text8_len,
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Failed to fault unclosed doc");
-    if (found_rsqb == 0)
-        fail("Did not catch the right square bracket");
-
-    /* Try again with a different encoding */
-    XML_ParserReset(parser, NULL);
-    XML_SetCharacterDataHandler(parser, rsqb_handler);
-    XML_SetUserData(parser, &found_rsqb);
-    found_rsqb = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text16, (int)sizeof(text16)-1,
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Failed to fault unclosed doc");
-    if (found_rsqb == 0)
-        fail("Did not catch the right square bracket");
-
-    /* And finally with a default handler */
-    XML_ParserReset(parser, NULL);
-    XML_SetDefaultHandler(parser, rsqb_handler);
-    XML_SetUserData(parser, &found_rsqb);
-    found_rsqb = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text16, (int)sizeof(text16)-1,
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Failed to fault unclosed doc");
-    if (found_rsqb == 0)
-        fail("Did not catch the right square bracket");
+rsqb_handler(void *userData, const XML_Char *s, int len) {
+  int *pfound = (int *)userData;
+
+  if (len == 1 && *s == XCS(']'))
+    *pfound = 1;
+}
+
+START_TEST(test_trailing_rsqb) {
+  const char *text8 = "<doc>]";
+  const char text16[] = "\xFF\xFE<\000d\000o\000c\000>\000]\000";
+  int found_rsqb;
+  int text8_len = (int)strlen(text8);
+
+  XML_SetCharacterDataHandler(g_parser, rsqb_handler);
+  XML_SetUserData(g_parser, &found_rsqb);
+  found_rsqb = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text8, text8_len, XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Failed to fault unclosed doc");
+  if (found_rsqb == 0)
+    fail("Did not catch the right square bracket");
+
+  /* Try again with a different encoding */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetCharacterDataHandler(g_parser, rsqb_handler);
+  XML_SetUserData(g_parser, &found_rsqb);
+  found_rsqb = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text16, (int)sizeof(text16) - 1,
+                              XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Failed to fault unclosed doc");
+  if (found_rsqb == 0)
+    fail("Did not catch the right square bracket");
+
+  /* And finally with a default handler */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetDefaultHandler(g_parser, rsqb_handler);
+  XML_SetUserData(g_parser, &found_rsqb);
+  found_rsqb = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text16, (int)sizeof(text16) - 1,
+                              XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Failed to fault unclosed doc");
+  if (found_rsqb == 0)
+    fail("Did not catch the right square bracket");
 }
 END_TEST
 
 /* Test trailing right square bracket in an external entity parse */
 static int XMLCALL
-external_entity_rsqb_catcher(XML_Parser parser,
-                             const XML_Char *context,
-                             const XML_Char *UNUSED_P(base),
-                             const XML_Char *UNUSED_P(systemId),
-                             const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<tag>]";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetCharacterDataHandler(ext_parser, rsqb_handler);
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Async entity error not caught");
-    if (XML_GetErrorCode(ext_parser) != XML_ERROR_ASYNC_ENTITY)
-        xml_failure(ext_parser);
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ext_entity_trailing_rsqb)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    int found_rsqb;
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_rsqb_catcher);
-    XML_SetUserData(parser, &found_rsqb);
-    found_rsqb = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
-    if (found_rsqb == 0)
-        fail("No right square bracket found");
+external_entity_rsqb_catcher(XML_Parser parser, const XML_Char *context,
+                             const XML_Char *base, const XML_Char *systemId,
+                             const XML_Char *publicId) {
+  const char *text = "<tag>]";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetCharacterDataHandler(ext_parser, rsqb_handler);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Async entity error not caught");
+  if (XML_GetErrorCode(ext_parser) != XML_ERROR_ASYNC_ENTITY)
+    xml_failure(ext_parser);
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ext_entity_trailing_rsqb) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  int found_rsqb;
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_rsqb_catcher);
+  XML_SetUserData(g_parser, &found_rsqb);
+  found_rsqb = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_OK)
+    xml_failure(g_parser);
+  if (found_rsqb == 0)
+    fail("No right square bracket found");
 }
 END_TEST
 
 /* Test CDATA handling in an external entity */
 static int XMLCALL
-external_entity_good_cdata_ascii(XML_Parser parser,
-                                 const XML_Char *context,
-                                 const XML_Char *UNUSED_P(base),
-                                 const XML_Char *UNUSED_P(systemId),
-                                 const XML_Char *UNUSED_P(publicId))
-{
-    const char *text =
-        "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
-    const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
-    CharData storage;
-    XML_Parser ext_parser;
-
-    CharData_Init(&storage);
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    XML_SetUserData(ext_parser, &storage);
-    XML_SetCharacterDataHandler(ext_parser, accumulate_characters);
-
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(ext_parser);
-    CharData_CheckXMLChars(&storage, expected);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ext_entity_good_cdata)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_good_cdata_ascii);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
+external_entity_good_cdata_ascii(XML_Parser parser, const XML_Char *context,
+                                 const XML_Char *base, const XML_Char *systemId,
+                                 const XML_Char *publicId) {
+  const char *text = "<a><![CDATA[<greeting>Hello, world!</greeting>]]></a>";
+  const XML_Char *expected = XCS("<greeting>Hello, world!</greeting>");
+  CharData storage;
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  CharData_Init(&storage);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  XML_SetUserData(ext_parser, &storage);
+  XML_SetCharacterDataHandler(ext_parser, accumulate_characters);
+
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(ext_parser);
+  CharData_CheckXMLChars(&storage, expected);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ext_entity_good_cdata) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_good_cdata_ascii);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_OK)
+    xml_failure(g_parser);
 }
 END_TEST
 
@@ -3820,105 +3546,100 @@ static int skip_count = 0;
 static int xdecl_count = 0;
 
 static void XMLCALL
-xml_decl_handler(void *userData,
-                 const XML_Char *UNUSED_P(version),
-                 const XML_Char *UNUSED_P(encoding),
-                 int standalone)
-{
-    if (userData != handler_data)
-        fail("User data (xml decl) not correctly set");
-    if (standalone != -1)
-        fail("Standalone not flagged as not present in XML decl");
-    xdecl_count++;
+xml_decl_handler(void *userData, const XML_Char *version,
+                 const XML_Char *encoding, int standalone) {
+  UNUSED_P(version);
+  UNUSED_P(encoding);
+  if (userData != handler_data)
+    fail("User data (xml decl) not correctly set");
+  if (standalone != -1)
+    fail("Standalone not flagged as not present in XML decl");
+  xdecl_count++;
 }
 
 static void XMLCALL
-param_check_skip_handler(void *userData,
-                         const XML_Char *UNUSED_P(entityName),
-                         int UNUSED_P(is_parameter_entity))
-{
-    if (userData != handler_data)
-        fail("User data (skip) not correctly set");
-    skip_count++;
+param_check_skip_handler(void *userData, const XML_Char *entityName,
+                         int is_parameter_entity) {
+  UNUSED_P(entityName);
+  UNUSED_P(is_parameter_entity);
+  if (userData != handler_data)
+    fail("User data (skip) not correctly set");
+  skip_count++;
 }
 
 static void XMLCALL
-data_check_comment_handler(void *userData, const XML_Char *UNUSED_P(data))
-{
-    /* Check that the userData passed through is what we expect */
-    if (userData != handler_data)
-        fail("User data (parser) not correctly set");
-    /* Check that the user data in the parser is appropriate */
-    if (XML_GetUserData(userData) != (void *)1)
-        fail("User data in parser not correctly set");
-    comment_count++;
+data_check_comment_handler(void *userData, const XML_Char *data) {
+  UNUSED_P(data);
+  /* Check that the userData passed through is what we expect */
+  if (userData != handler_data)
+    fail("User data (parser) not correctly set");
+  /* Check that the user data in the parser is appropriate */
+  if (XML_GetUserData(userData) != (void *)1)
+    fail("User data in parser not correctly set");
+  comment_count++;
 }
 
 static int XMLCALL
-external_entity_param_checker(XML_Parser parser,
-                              const XML_Char *context,
-                              const XML_Char *UNUSED_P(base),
-                              const XML_Char *UNUSED_P(systemId),
-                              const XML_Char *UNUSED_P(publicId))
-{
-    const char *text =
-        "<!-- Subordinate parser -->\n"
-        "<!ELEMENT doc (#PCDATA)*>";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    handler_data = ext_parser;
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(parser);
-        return XML_STATUS_ERROR;
-    }
-    handler_data = parser;
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_user_parameters)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!-- Primary parse -->\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;";
-    const char *epilog =
-        "<!-- Back to primary parser -->\n"
-        "</doc>";
-
-    comment_count = 0;
-    skip_count = 0;
-    xdecl_count = 0;
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetXmlDeclHandler(parser, xml_decl_handler);
-    XML_SetExternalEntityRefHandler(parser, external_entity_param_checker);
-    XML_SetCommentHandler(parser, data_check_comment_handler);
-    XML_SetSkippedEntityHandler(parser, param_check_skip_handler);
-    XML_UseParserAsHandlerArg(parser);
-    XML_SetUserData(parser, (void *)1);
-    handler_data = parser;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (comment_count != 2)
-        fail("Comment handler not invoked enough times");
-    /* Ensure we can't change policy mid-parse */
-    if (XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_NEVER))
-        fail("Changed param entity parsing policy while parsing");
-    if (_XML_Parse_SINGLE_BYTES(parser, epilog, (int)strlen(epilog),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (comment_count != 3)
-        fail("Comment handler not invoked enough times");
-    if (skip_count != 1)
-        fail("Skip handler not invoked enough times");
-    if (xdecl_count != 1)
-        fail("XML declaration handler not invoked");
+external_entity_param_checker(XML_Parser parser, const XML_Char *context,
+                              const XML_Char *base, const XML_Char *systemId,
+                              const XML_Char *publicId) {
+  const char *text = "<!-- Subordinate parser -->\n"
+                     "<!ELEMENT doc (#PCDATA)*>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  handler_data = ext_parser;
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(parser);
+    return XML_STATUS_ERROR;
+  }
+  handler_data = parser;
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_user_parameters) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!-- Primary parse -->\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;";
+  const char *epilog = "<!-- Back to primary parser -->\n"
+                       "</doc>";
+
+  comment_count = 0;
+  skip_count = 0;
+  xdecl_count = 0;
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetXmlDeclHandler(g_parser, xml_decl_handler);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_param_checker);
+  XML_SetCommentHandler(g_parser, data_check_comment_handler);
+  XML_SetSkippedEntityHandler(g_parser, param_check_skip_handler);
+  XML_UseParserAsHandlerArg(g_parser);
+  XML_SetUserData(g_parser, (void *)1);
+  handler_data = g_parser;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (comment_count != 2)
+    fail("Comment handler not invoked enough times");
+  /* Ensure we can't change policy mid-parse */
+  if (XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_NEVER))
+    fail("Changed param entity parsing policy while parsing");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, epilog, (int)strlen(epilog), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (comment_count != 3)
+    fail("Comment handler not invoked enough times");
+  if (skip_count != 1)
+    fail("Skip handler not invoked enough times");
+  if (xdecl_count != 1)
+    fail("XML declaration handler not invoked");
 }
 END_TEST
 
@@ -3932,108 +3653,104 @@ END_TEST
  * since there are code paths we need to ensure get executed.
  */
 static int XMLCALL
-external_entity_ref_param_checker(XML_Parser parameter,
-                                  const XML_Char *context,
-                                  const XML_Char *UNUSED_P(base),
-                                  const XML_Char *UNUSED_P(systemId),
-                                  const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<!ELEMENT doc (#PCDATA)*>";
-    XML_Parser ext_parser;
-
-    if ((void *)parameter != handler_data)
-        fail("External entity ref handler parameter not correct");
-
-    /* Here we use the global 'parser' variable */
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(ext_parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ext_entity_ref_parameter)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_ref_param_checker);
-    /* Set a handler arg that is not NULL and not parser (which is
-     * what NULL would cause to be passed.
-     */
-    XML_SetExternalEntityRefHandlerArg(parser, (void *)text);
-    handler_data = (void *)text;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    /* Now try again with unset args */
-    XML_ParserReset(parser, NULL);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_ref_param_checker);
-    XML_SetExternalEntityRefHandlerArg(parser, NULL);
-    handler_data = (void *)parser;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+external_entity_ref_param_checker(XML_Parser parameter, const XML_Char *context,
+                                  const XML_Char *base,
+                                  const XML_Char *systemId,
+                                  const XML_Char *publicId) {
+  const char *text = "<!ELEMENT doc (#PCDATA)*>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  if ((void *)parameter != handler_data)
+    fail("External entity ref handler parameter not correct");
+
+  /* Here we use the global 'parser' variable */
+  ext_parser = XML_ExternalEntityParserCreate(g_parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(ext_parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ext_entity_ref_parameter) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_ref_param_checker);
+  /* Set a handler arg that is not NULL and not parser (which is
+   * what NULL would cause to be passed.
+   */
+  XML_SetExternalEntityRefHandlerArg(g_parser, (void *)text);
+  handler_data = (void *)text;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  /* Now try again with unset args */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_ref_param_checker);
+  XML_SetExternalEntityRefHandlerArg(g_parser, NULL);
+  handler_data = (void *)g_parser;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test the parsing of an empty string */
-START_TEST(test_empty_parse)
-{
-    const char *text = "<doc></doc>";
-    const char *partial = "<doc>";
-
-    if (XML_Parse(parser, NULL, 0, XML_FALSE) == XML_STATUS_ERROR)
-        fail("Parsing empty string faulted");
-    if (XML_Parse(parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
-        fail("Parsing final empty string not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_NO_ELEMENTS)
-        fail("Parsing final empty string faulted for wrong reason");
-
-    /* Now try with valid text before the empty end */
-    XML_ParserReset(parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (XML_Parse(parser, NULL, 0, XML_TRUE) == XML_STATUS_ERROR)
-        fail("Parsing final empty string faulted");
-
-    /* Now try with invalid text before the empty end */
-    XML_ParserReset(parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, partial, (int)strlen(partial),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (XML_Parse(parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
-        fail("Parsing final incomplete empty string not faulted");
+START_TEST(test_empty_parse) {
+  const char *text = "<doc></doc>";
+  const char *partial = "<doc>";
+
+  if (XML_Parse(g_parser, NULL, 0, XML_FALSE) == XML_STATUS_ERROR)
+    fail("Parsing empty string faulted");
+  if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
+    fail("Parsing final empty string not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NO_ELEMENTS)
+    fail("Parsing final empty string faulted for wrong reason");
+
+  /* Now try with valid text before the empty end */
+  XML_ParserReset(g_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (XML_Parse(g_parser, NULL, 0, XML_TRUE) == XML_STATUS_ERROR)
+    fail("Parsing final empty string faulted");
+
+  /* Now try with invalid text before the empty end */
+  XML_ParserReset(g_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, partial, (int)strlen(partial),
+                              XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
+    fail("Parsing final incomplete empty string not faulted");
 }
 END_TEST
 
 /* Test odd corners of the XML_GetBuffer interface */
 static enum XML_Status
-get_feature(enum XML_FeatureEnum feature_id, long *presult)
-{
-    const XML_Feature *feature = XML_GetFeatureList();
+get_feature(enum XML_FeatureEnum feature_id, long *presult) {
+  const XML_Feature *feature = XML_GetFeatureList();
 
-    if (feature == NULL)
-        return XML_STATUS_ERROR;
-    for (; feature->feature != XML_FEATURE_END; feature++) {
-        if (feature->feature == feature_id) {
-            *presult = feature->value;
-            return XML_STATUS_OK;
-        }
-    }
+  if (feature == NULL)
     return XML_STATUS_ERROR;
+  for (; feature->feature != XML_FEATURE_END; feature++) {
+    if (feature->feature == feature_id) {
+      *presult = feature->value;
+      return XML_STATUS_OK;
+    }
+  }
+  return XML_STATUS_ERROR;
 }
 
 /* Having an element name longer than 1024 characters exercises some
@@ -4041,126 +3758,125 @@ get_feature(enum XML_FeatureEnum feature_id, long *presult)
  * get executed.  The count at the end of the line is the number of
  * characters (bytes) in the element name by that point.x
  */
-static const char *get_buffer_test_text =
-        "<documentwitharidiculouslylongelementnametotease" /* 0x030 */
-        "aparticularcorneroftheallocationinXML_GetBuffers" /* 0x060 */
-        "othatwecanimprovethecoverageyetagain012345678901" /* 0x090 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x0c0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x0f0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x120 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x150 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x180 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x1b0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x1e0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x210 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x240 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x270 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x2a0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x2d0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x300 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x330 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x360 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x390 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x3c0 */
-        "123456789abcdef0123456789abcdef0123456789abcdef0" /* 0x3f0 */
-        "123456789abcdef0123456789abcdef0123456789>\n<ef0"; /* 0x420 */
+static const char *get_buffer_test_text
+    = "<documentwitharidiculouslylongelementnametotease"  /* 0x030 */
+      "aparticularcorneroftheallocationinXML_GetBuffers"  /* 0x060 */
+      "othatwecanimprovethecoverageyetagain012345678901"  /* 0x090 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x0c0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x0f0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x120 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x150 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x180 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x1b0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x1e0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x210 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x240 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x270 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x2a0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x2d0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x300 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x330 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x360 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x390 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x3c0 */
+      "123456789abcdef0123456789abcdef0123456789abcdef0"  /* 0x3f0 */
+      "123456789abcdef0123456789abcdef0123456789>\n<ef0"; /* 0x420 */
 
 /* Test odd corners of the XML_GetBuffer interface */
-START_TEST(test_get_buffer_1)
-{
-    const char *text = get_buffer_test_text;
-    void *buffer;
-    long context_bytes;
-
-    /* Attempt to allocate a negative length buffer */
-    if (XML_GetBuffer(parser, -12) != NULL)
-        fail("Negative length buffer not failed");
-
-    /* Now get a small buffer and extend it past valid length */
-    buffer = XML_GetBuffer(parser, 1536);
-    if (buffer == NULL)
-        fail("1.5K buffer failed");
-    memcpy(buffer, text, strlen(text));
-    if (XML_ParseBuffer(parser, (int)strlen(text), XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (XML_GetBuffer(parser, INT_MAX) != NULL)
-        fail("INT_MAX buffer not failed");
-
-    /* Now try extending it a more reasonable but still too large
-     * amount.  The allocator in XML_GetBuffer() doubles the buffer
-     * size until it exceeds the requested amount or INT_MAX.  If it
-     * exceeds INT_MAX, it rejects the request, so we want a request
-     * between INT_MAX and INT_MAX/2.  A gap of 1K seems comfortable,
-     * with an extra byte just to ensure that the request is off any
-     * boundary.  The request will be inflated internally by
-     * XML_CONTEXT_BYTES (if defined), so we subtract that from our
-     * request.
-     */
-    if (get_feature(XML_FEATURE_CONTEXT_BYTES,
-                    &context_bytes) != XML_STATUS_OK)
-        context_bytes = 0;
-    if (XML_GetBuffer(parser, INT_MAX - (context_bytes + 1025)) != NULL)
-        fail("INT_MAX- buffer not failed");
-
-    /* Now try extending it a carefully crafted amount */
-    if (XML_GetBuffer(parser, 1000) == NULL)
-        fail("1000 buffer failed");
+START_TEST(test_get_buffer_1) {
+  const char *text = get_buffer_test_text;
+  void *buffer;
+  long context_bytes;
+
+  /* Attempt to allocate a negative length buffer */
+  if (XML_GetBuffer(g_parser, -12) != NULL)
+    fail("Negative length buffer not failed");
+
+  /* Now get a small buffer and extend it past valid length */
+  buffer = XML_GetBuffer(g_parser, 1536);
+  if (buffer == NULL)
+    fail("1.5K buffer failed");
+  assert(buffer != NULL);
+  memcpy(buffer, text, strlen(text));
+  if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (XML_GetBuffer(g_parser, INT_MAX) != NULL)
+    fail("INT_MAX buffer not failed");
+
+  /* Now try extending it a more reasonable but still too large
+   * amount.  The allocator in XML_GetBuffer() doubles the buffer
+   * size until it exceeds the requested amount or INT_MAX.  If it
+   * exceeds INT_MAX, it rejects the request, so we want a request
+   * between INT_MAX and INT_MAX/2.  A gap of 1K seems comfortable,
+   * with an extra byte just to ensure that the request is off any
+   * boundary.  The request will be inflated internally by
+   * XML_CONTEXT_BYTES (if defined), so we subtract that from our
+   * request.
+   */
+  if (get_feature(XML_FEATURE_CONTEXT_BYTES, &context_bytes) != XML_STATUS_OK)
+    context_bytes = 0;
+  if (XML_GetBuffer(g_parser, INT_MAX - (context_bytes + 1025)) != NULL)
+    fail("INT_MAX- buffer not failed");
+
+  /* Now try extending it a carefully crafted amount */
+  if (XML_GetBuffer(g_parser, 1000) == NULL)
+    fail("1000 buffer failed");
 }
 END_TEST
 
 /* Test more corners of the XML_GetBuffer interface */
-START_TEST(test_get_buffer_2)
-{
-    const char *text = get_buffer_test_text;
-    void *buffer;
+START_TEST(test_get_buffer_2) {
+  const char *text = get_buffer_test_text;
+  void *buffer;
 
-    /* Now get a decent buffer */
-    buffer = XML_GetBuffer(parser, 1536);
-    if (buffer == NULL)
-        fail("1.5K buffer failed");
-    memcpy(buffer, text, strlen(text));
-    if (XML_ParseBuffer(parser, (int)strlen(text), XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  /* Now get a decent buffer */
+  buffer = XML_GetBuffer(g_parser, 1536);
+  if (buffer == NULL)
+    fail("1.5K buffer failed");
+  assert(buffer != NULL);
+  memcpy(buffer, text, strlen(text));
+  if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 
-    /* Extend it, to catch a different code path */
-    if (XML_GetBuffer(parser, 1024) == NULL)
-        fail("1024 buffer failed");
+  /* Extend it, to catch a different code path */
+  if (XML_GetBuffer(g_parser, 1024) == NULL)
+    fail("1024 buffer failed");
 }
 END_TEST
 
 /* Test position information macros */
-START_TEST(test_byte_info_at_end)
-{
-    const char *text = "<doc></doc>";
+START_TEST(test_byte_info_at_end) {
+  const char *text = "<doc></doc>";
 
-    if (XML_GetCurrentByteIndex(parser) != -1 ||
-        XML_GetCurrentByteCount(parser) != 0)
-        fail("Byte index/count incorrect at start of parse");
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* At end, the count will be zero and the index the end of string */
-    if (XML_GetCurrentByteCount(parser) != 0)
-        fail("Terminal byte count incorrect");
-    if (XML_GetCurrentByteIndex(parser) != (XML_Index)strlen(text))
-        fail("Terminal byte index incorrect");
+  if (XML_GetCurrentByteIndex(g_parser) != -1
+      || XML_GetCurrentByteCount(g_parser) != 0)
+    fail("Byte index/count incorrect at start of parse");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* At end, the count will be zero and the index the end of string */
+  if (XML_GetCurrentByteCount(g_parser) != 0)
+    fail("Terminal byte count incorrect");
+  if (XML_GetCurrentByteIndex(g_parser) != (XML_Index)strlen(text))
+    fail("Terminal byte index incorrect");
 }
 END_TEST
 
 /* Test position information from errors */
-#define PRE_ERROR_STR  "<doc></"
+#define PRE_ERROR_STR "<doc></"
 #define POST_ERROR_STR "wombat></doc>"
-START_TEST(test_byte_info_at_error)
-{
-    const char *text = PRE_ERROR_STR POST_ERROR_STR;
+START_TEST(test_byte_info_at_error) {
+  const char *text = PRE_ERROR_STR POST_ERROR_STR;
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_OK)
-        fail("Syntax error not faulted");
-    if (XML_GetCurrentByteCount(parser) != 0)
-        fail("Error byte count incorrect");
-    if (XML_GetCurrentByteIndex(parser) != strlen(PRE_ERROR_STR))
-        fail("Error byte index incorrect");
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_OK)
+    fail("Syntax error not faulted");
+  if (XML_GetCurrentByteCount(g_parser) != 0)
+    fail("Error byte count incorrect");
+  if (XML_GetCurrentByteIndex(g_parser) != strlen(PRE_ERROR_STR))
+    fail("Error byte index incorrect");
 }
 END_TEST
 #undef PRE_ERROR_STR
@@ -4168,60 +3884,58 @@ END_TEST
 
 /* Test position information in handler */
 typedef struct ByteTestData {
-    int start_element_len;
-    int cdata_len;
-    int total_string_len;
+  int start_element_len;
+  int cdata_len;
+  int total_string_len;
 } ByteTestData;
 
 static void
-byte_character_handler(void *userData,
-                       const XML_Char *UNUSED_P(s),
-                       int len)
-{
+byte_character_handler(void *userData, const XML_Char *s, int len) {
 #ifdef XML_CONTEXT_BYTES
-    int offset, size;
-    const char *buffer;
-    ByteTestData *data = (ByteTestData *)userData;
-
-    buffer = XML_GetInputContext(parser, &offset, &size);
-    if (buffer == NULL)
-        fail("Failed to get context buffer");
-    if (offset != data->start_element_len)
-        fail("Context offset in unexpected position");
-    if (len != data->cdata_len)
-        fail("CDATA length reported incorrectly");
-    if (size != data->total_string_len)
-        fail("Context size is not full buffer");
-    if (XML_GetCurrentByteIndex(parser) != offset)
-        fail("Character byte index incorrect");
-    if (XML_GetCurrentByteCount(parser) != len)
-        fail("Character byte count incorrect");
+  int offset, size;
+  const char *buffer;
+  ByteTestData *data = (ByteTestData *)userData;
+
+  UNUSED_P(s);
+  buffer = XML_GetInputContext(g_parser, &offset, &size);
+  if (buffer == NULL)
+    fail("Failed to get context buffer");
+  if (offset != data->start_element_len)
+    fail("Context offset in unexpected position");
+  if (len != data->cdata_len)
+    fail("CDATA length reported incorrectly");
+  if (size != data->total_string_len)
+    fail("Context size is not full buffer");
+  if (XML_GetCurrentByteIndex(g_parser) != offset)
+    fail("Character byte index incorrect");
+  if (XML_GetCurrentByteCount(g_parser) != len)
+    fail("Character byte count incorrect");
 #else
-    (void)userData;
-    (void)len;
+  UNUSED_P(s);
+  UNUSED_P(userData);
+  UNUSED_P(len);
 #endif
 }
 
 #define START_ELEMENT "<e>"
-#define CDATA_TEXT    "Hello"
-#define END_ELEMENT   "</e>"
-START_TEST(test_byte_info_at_cdata)
-{
-    const char *text = START_ELEMENT CDATA_TEXT END_ELEMENT;
-    int offset, size;
-    ByteTestData data;
-
-    /* Check initial context is empty */
-    if (XML_GetInputContext(parser, &offset, &size) != NULL)
-        fail("Unexpected context at start of parse");
-
-    data.start_element_len = (int)strlen(START_ELEMENT);
-    data.cdata_len = (int)strlen(CDATA_TEXT);
-    data.total_string_len = (int)strlen(text);
-    XML_SetCharacterDataHandler(parser, byte_character_handler);
-    XML_SetUserData(parser, &data);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
+#define CDATA_TEXT "Hello"
+#define END_ELEMENT "</e>"
+START_TEST(test_byte_info_at_cdata) {
+  const char *text = START_ELEMENT CDATA_TEXT END_ELEMENT;
+  int offset, size;
+  ByteTestData data;
+
+  /* Check initial context is empty */
+  if (XML_GetInputContext(g_parser, &offset, &size) != NULL)
+    fail("Unexpected context at start of parse");
+
+  data.start_element_len = (int)strlen(START_ELEMENT);
+  data.cdata_len = (int)strlen(CDATA_TEXT);
+  data.total_string_len = (int)strlen(text);
+  XML_SetCharacterDataHandler(g_parser, byte_character_handler);
+  XML_SetUserData(g_parser, &data);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_OK)
+    xml_failure(g_parser);
 }
 END_TEST
 #undef START_ELEMENT
@@ -4229,28 +3943,27 @@ END_TEST
 #undef END_ELEMENT
 
 /* Test predefined entities are correctly recognised */
-START_TEST(test_predefined_entities)
-{
-    const char *text = "<doc>&lt;&gt;&amp;&quot;&apos;</doc>";
-    const XML_Char *expected = XCS("<doc>&lt;&gt;&amp;&quot;&apos;</doc>");
-    const XML_Char *result = XCS("<>&\"'");
-    CharData storage;
-
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    /* run_character_check uses XML_SetCharacterDataHandler(), which
-     * unfortunately heads off a code path that we need to exercise.
-     */
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* The default handler doesn't translate the entities */
-    CharData_CheckXMLChars(&storage, expected);
-
-    /* Now try again and check the translation */
-    XML_ParserReset(parser, NULL);
-    run_character_check(text, result);
+START_TEST(test_predefined_entities) {
+  const char *text = "<doc>&lt;&gt;&amp;&quot;&apos;</doc>";
+  const XML_Char *expected = XCS("<doc>&lt;&gt;&amp;&quot;&apos;</doc>");
+  const XML_Char *result = XCS("<>&\"'");
+  CharData storage;
+
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  /* run_character_check uses XML_SetCharacterDataHandler(), which
+   * unfortunately heads off a code path that we need to exercise.
+   */
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* The default handler doesn't translate the entities */
+  CharData_CheckXMLChars(&storage, expected);
+
+  /* Now try again and check the translation */
+  XML_ParserReset(g_parser, NULL);
+  run_character_check(text, result);
 }
 END_TEST
 
@@ -4263,572 +3976,470 @@ END_TEST
  * error on encountering it.
  */
 static int XMLCALL
-external_entity_param(XML_Parser parser,
-                      const XML_Char *context,
-                      const XML_Char *UNUSED_P(base),
-                      const XML_Char *systemId,
-                      const XML_Char *UNUSED_P(publicId))
-{
-    const char *text1 =
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
-        "<!ENTITY % e2 '%e1;'>\n"
-        "%e1;\n";
-    const char *text2 =
-        "<!ELEMENT el EMPTY>\n"
-        "<el/>\n";
-    XML_Parser ext_parser;
-
-    if (systemId == NULL)
-        return XML_STATUS_OK;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-
-    if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            fail("Inner DTD with invalid tag not rejected");
-        if (XML_GetErrorCode(ext_parser) != XML_ERROR_EXTERNAL_ENTITY_HANDLING)
-            xml_failure(ext_parser);
-    }
-    else if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            fail("Invalid tag in external param not rejected");
-        if (XML_GetErrorCode(ext_parser) != XML_ERROR_SYNTAX)
-            xml_failure(ext_parser);
-    } else {
-        fail("Unknown system ID");
-    }
+external_entity_param(XML_Parser parser, const XML_Char *context,
+                      const XML_Char *base, const XML_Char *systemId,
+                      const XML_Char *publicId) {
+  const char *text1 = "<!ELEMENT doc EMPTY>\n"
+                      "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
+                      "<!ENTITY % e2 '%e1;'>\n"
+                      "%e1;\n";
+  const char *text2 = "<!ELEMENT el EMPTY>\n"
+                      "<el/>\n";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  if (systemId == NULL)
+    return XML_STATUS_OK;
 
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_ERROR;
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+
+  if (! xcstrcmp(systemId, XCS("004-1.ent"))) {
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1), XML_TRUE)
+        != XML_STATUS_ERROR)
+      fail("Inner DTD with invalid tag not rejected");
+    if (XML_GetErrorCode(ext_parser) != XML_ERROR_EXTERNAL_ENTITY_HANDLING)
+      xml_failure(ext_parser);
+  } else if (! xcstrcmp(systemId, XCS("004-2.ent"))) {
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2), XML_TRUE)
+        != XML_STATUS_ERROR)
+      fail("Invalid tag in external param not rejected");
+    if (XML_GetErrorCode(ext_parser) != XML_ERROR_SYNTAX)
+      xml_failure(ext_parser);
+  } else {
+    fail("Unknown system ID");
+  }
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_ERROR;
 }
 
-START_TEST(test_invalid_tag_in_dtd)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
-        "<doc></doc>\n";
+START_TEST(test_invalid_tag_in_dtd) {
+  const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
+                     "<doc></doc>\n";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_param);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Invalid tag IN DTD external param not rejected");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_param);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Invalid tag IN DTD external param not rejected");
 }
 END_TEST
 
 /* Test entities not quite the predefined ones are not mis-recognised */
-START_TEST(test_not_predefined_entities)
-{
-    const char *text[] = {
-        "<doc>&pt;</doc>",
-        "<doc>&amo;</doc>",
-        "<doc>&quid;</doc>",
-        "<doc>&apod;</doc>",
-        NULL
-    };
-    int i = 0;
-
-    while (text[i] != NULL) {
-        expect_failure(text[i], XML_ERROR_UNDEFINED_ENTITY,
-                       "Undefined entity not rejected");
-        XML_ParserReset(parser, NULL);
-        i++;
-    }
+START_TEST(test_not_predefined_entities) {
+  const char *text[] = {"<doc>&pt;</doc>", "<doc>&amo;</doc>",
+                        "<doc>&quid;</doc>", "<doc>&apod;</doc>", NULL};
+  int i = 0;
+
+  while (text[i] != NULL) {
+    expect_failure(text[i], XML_ERROR_UNDEFINED_ENTITY,
+                   "Undefined entity not rejected");
+    XML_ParserReset(g_parser, NULL);
+    i++;
+  }
 }
 END_TEST
 
 /* Test conditional inclusion (IGNORE) */
 static int XMLCALL
-external_entity_load_ignore(XML_Parser parser,
-                            const XML_Char *context,
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = "<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ignore_section)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc><e>&entity;</e></doc>";
-    const XML_Char *expected =
-        XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&entity;");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &storage);
-    XML_SetExternalEntityRefHandler(parser, external_entity_load_ignore);
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetStartDoctypeDeclHandler(parser, dummy_start_doctype_handler);
-    XML_SetEndDoctypeDeclHandler(parser, dummy_end_doctype_handler);
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    XML_SetStartElementHandler(parser, dummy_start_element);
-    XML_SetEndElementHandler(parser, dummy_end_element);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+external_entity_load_ignore(XML_Parser parser, const XML_Char *context,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  const char *text = "<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ignore_section) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc><e>&entity;</e></doc>";
+  const XML_Char *expected
+      = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&entity;");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_load_ignore);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
+  XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  XML_SetStartElementHandler(g_parser, dummy_start_element);
+  XML_SetEndElementHandler(g_parser, dummy_end_element);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 static int XMLCALL
-external_entity_load_ignore_utf16(XML_Parser parser,
-                                  const XML_Char *context,
-                                  const XML_Char *UNUSED_P(base),
-                                  const XML_Char *UNUSED_P(systemId),
-                                  const XML_Char *UNUSED_P(publicId))
-{
-    const char text[] =
-        /* <![IGNORE[<!ELEMENT e (#PCDATA)*>]]> */
-        "<\0!\0[\0I\0G\0N\0O\0R\0E\0[\0"
-        "<\0!\0E\0L\0E\0M\0E\0N\0T\0 \0e\0 \0"
-        "(\0#\0P\0C\0D\0A\0T\0A\0)\0*\0>\0]\0]\0>\0";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ignore_section_utf16)
-{
-    const char text[] =
-        /* <!DOCTYPE d SYSTEM 's'> */
-        "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
-        "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n\0"
-        /* <d><e>&en;</e></d> */
-        "<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>\0";
-    const XML_Char *expected =
-        XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &storage);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_load_ignore_utf16);
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetStartDoctypeDeclHandler(parser, dummy_start_doctype_handler);
-    XML_SetEndDoctypeDeclHandler(parser, dummy_end_doctype_handler);
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    XML_SetStartElementHandler(parser, dummy_start_element);
-    XML_SetEndElementHandler(parser, dummy_end_element);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+external_entity_load_ignore_utf16(XML_Parser parser, const XML_Char *context,
+                                  const XML_Char *base,
+                                  const XML_Char *systemId,
+                                  const XML_Char *publicId) {
+  const char text[] =
+      /* <![IGNORE[<!ELEMENT e (#PCDATA)*>]]> */
+      "<\0!\0[\0I\0G\0N\0O\0R\0E\0[\0"
+      "<\0!\0E\0L\0E\0M\0E\0N\0T\0 \0e\0 \0"
+      "(\0#\0P\0C\0D\0A\0T\0A\0)\0*\0>\0]\0]\0>\0";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ignore_section_utf16) {
+  const char text[] =
+      /* <!DOCTYPE d SYSTEM 's'> */
+      "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
+      "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n\0"
+      /* <d><e>&en;</e></d> */
+      "<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>\0";
+  const XML_Char *expected = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_load_ignore_utf16);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
+  XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  XML_SetStartElementHandler(g_parser, dummy_start_element);
+  XML_SetEndElementHandler(g_parser, dummy_end_element);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 static int XMLCALL
-external_entity_load_ignore_utf16_be(XML_Parser parser,
-                                     const XML_Char *context,
-                                     const XML_Char *UNUSED_P(base),
-                                     const XML_Char *UNUSED_P(systemId),
-                                     const XML_Char *UNUSED_P(publicId))
-{
-    const char text[] =
-        /* <![IGNORE[<!ELEMENT e (#PCDATA)*>]]> */
-        "\0<\0!\0[\0I\0G\0N\0O\0R\0E\0["
-        "\0<\0!\0E\0L\0E\0M\0E\0N\0T\0 \0e\0 "
-        "\0(\0#\0P\0C\0D\0A\0T\0A\0)\0*\0>\0]\0]\0>";
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_ignore_section_utf16_be)
-{
-    const char text[] =
-        /* <!DOCTYPE d SYSTEM 's'> */
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
-        "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n"
-        /* <d><e>&en;</e></d> */
-        "\0<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>";
-    const XML_Char *expected =
-        XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, &storage);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_load_ignore_utf16_be);
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetStartDoctypeDeclHandler(parser, dummy_start_doctype_handler);
-    XML_SetEndDoctypeDeclHandler(parser, dummy_end_doctype_handler);
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    XML_SetStartElementHandler(parser, dummy_start_element);
-    XML_SetEndElementHandler(parser, dummy_end_element);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+external_entity_load_ignore_utf16_be(XML_Parser parser, const XML_Char *context,
+                                     const XML_Char *base,
+                                     const XML_Char *systemId,
+                                     const XML_Char *publicId) {
+  const char text[] =
+      /* <![IGNORE[<!ELEMENT e (#PCDATA)*>]]> */
+      "\0<\0!\0[\0I\0G\0N\0O\0R\0E\0["
+      "\0<\0!\0E\0L\0E\0M\0E\0N\0T\0 \0e\0 "
+      "\0(\0#\0P\0C\0D\0A\0T\0A\0)\0*\0>\0]\0]\0>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_ignore_section_utf16_be) {
+  const char text[] =
+      /* <!DOCTYPE d SYSTEM 's'> */
+      "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 "
+      "\0S\0Y\0S\0T\0E\0M\0 \0'\0s\0'\0>\0\n"
+      /* <d><e>&en;</e></d> */
+      "\0<\0d\0>\0<\0e\0>\0&\0e\0n\0;\0<\0/\0e\0>\0<\0/\0d\0>";
+  const XML_Char *expected = XCS("<![IGNORE[<!ELEMENT e (#PCDATA)*>]]>\n&en;");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetExternalEntityRefHandler(g_parser,
+                                  external_entity_load_ignore_utf16_be);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetStartDoctypeDeclHandler(g_parser, dummy_start_doctype_handler);
+  XML_SetEndDoctypeDeclHandler(g_parser, dummy_end_doctype_handler);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  XML_SetStartElementHandler(g_parser, dummy_start_element);
+  XML_SetEndElementHandler(g_parser, dummy_end_element);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test mis-formatted conditional exclusion */
-START_TEST(test_bad_ignore_section)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc><e>&entity;</e></doc>";
-    ExtFaults faults[] = {
-        {
-            "<![IGNORE[<!ELEM",
-            "Broken-off declaration not faulted",
-            NULL,
-            XML_ERROR_SYNTAX
-        },
-        {
-            "<![IGNORE[\x01]]>",
-            "Invalid XML character not faulted",
-            NULL,
-            XML_ERROR_INVALID_TOKEN
-        },
-        {
-            /* FIrst two bytes of a three-byte char */
-            "<![IGNORE[\xe2\x82",
-            "Partial XML character not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        { NULL, NULL, NULL, XML_ERROR_NONE }
-    };
-    ExtFaults *fault;
-
-    for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-        XML_SetUserData(parser, fault);
-        expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                       "Incomplete IGNORE section not failed");
-        XML_ParserReset(parser, NULL);
-    }
+START_TEST(test_bad_ignore_section) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc><e>&entity;</e></doc>";
+  ExtFaults faults[]
+      = {{"<![IGNORE[<!ELEM", "Broken-off declaration not faulted", NULL,
+          XML_ERROR_SYNTAX},
+         {"<![IGNORE[\x01]]>", "Invalid XML character not faulted", NULL,
+          XML_ERROR_INVALID_TOKEN},
+         {/* FIrst two bytes of a three-byte char */
+          "<![IGNORE[\xe2\x82", "Partial XML character not faulted", NULL,
+          XML_ERROR_PARTIAL_CHAR},
+         {NULL, NULL, NULL, XML_ERROR_NONE}};
+  ExtFaults *fault;
+
+  for (fault = &faults[0]; fault->parse_text != NULL; fault++) {
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+    XML_SetUserData(g_parser, fault);
+    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                   "Incomplete IGNORE section not failed");
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
 /* Test recursive parsing */
 static int XMLCALL
-external_entity_valuer(XML_Parser parser,
-                       const XML_Char *context,
-                       const XML_Char *UNUSED_P(base),
-                       const XML_Char *systemId,
-                       const XML_Char *UNUSED_P(publicId))
-{
-    const char *text1 =
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
-        "<!ENTITY % e2 '%e1;'>\n"
-        "%e1;\n";
-    XML_Parser ext_parser;
-
-    if (systemId == NULL)
-        return XML_STATUS_OK;
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1),
-                                    XML_TRUE) == XML_STATUS_ERROR)
-            xml_failure(ext_parser);
-    }
-    else if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
-        ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
-        enum XML_Status status;
-        enum XML_Error error;
-
-        status = _XML_Parse_SINGLE_BYTES(ext_parser,
-                                         fault->parse_text,
-                                         (int)strlen(fault->parse_text),
-                                         XML_TRUE);
-        if (fault->error == XML_ERROR_NONE) {
-            if (status == XML_STATUS_ERROR)
-                xml_failure(ext_parser);
-        } else {
-            if (status != XML_STATUS_ERROR)
-                fail(fault->fail_text);
-            error = XML_GetErrorCode(ext_parser);
-            if (error != fault->error &&
-                (fault->error != XML_ERROR_XML_DECL ||
-                 error != XML_ERROR_TEXT_DECL))
-                xml_failure(ext_parser);
-        }
-    }
-
-    XML_ParserFree(ext_parser);
+external_entity_valuer(XML_Parser parser, const XML_Char *context,
+                       const XML_Char *base, const XML_Char *systemId,
+                       const XML_Char *publicId) {
+  const char *text1 = "<!ELEMENT doc EMPTY>\n"
+                      "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
+                      "<!ENTITY % e2 '%e1;'>\n"
+                      "%e1;\n";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  if (systemId == NULL)
     return XML_STATUS_OK;
-}
-
-START_TEST(test_external_entity_values)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
-        "<doc></doc>\n";
-    ExtFaults data_004_2[] = {
-        {
-            "<!ATTLIST doc a1 CDATA 'value'>",
-            NULL,
-            NULL,
-            XML_ERROR_NONE
-        },
-        {
-            "<!ATTLIST $doc a1 CDATA 'value'>",
-            "Invalid token not faulted",
-            NULL,
-            XML_ERROR_INVALID_TOKEN
-        },
-        {
-            "'wombat",
-            "Unterminated string not faulted",
-            NULL,
-            XML_ERROR_UNCLOSED_TOKEN
-        },
-        {
-            "\xe2\x82",
-            "Partial UTF-8 character not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        {
-            "<?xml version='1.0' encoding='utf-8'?>\n",
-            NULL,
-            NULL,
-            XML_ERROR_NONE
-        },
-        {
-            "<?xml?>",
-            "Malformed XML declaration not faulted",
-            NULL,
-            XML_ERROR_XML_DECL
-        },
-        {
-            /* UTF-8 BOM */
-            "\xEF\xBB\xBF<!ATTLIST doc a1 CDATA 'value'>",
-            NULL,
-            NULL,
-            XML_ERROR_NONE
-        },
-        {
-            "<?xml version='1.0' encoding='utf-8'?>\n$",
-            "Invalid token after text declaration not faulted",
-            NULL,
-            XML_ERROR_INVALID_TOKEN
-        },
-        {
-            "<?xml version='1.0' encoding='utf-8'?>\n'wombat",
-            "Unterminated string after text decl not faulted",
-            NULL,
-            XML_ERROR_UNCLOSED_TOKEN
-        },
-        {
-            "<?xml version='1.0' encoding='utf-8'?>\n\xe2\x82",
-            "Partial UTF-8 character after text decl not faulted",
-            NULL,
-            XML_ERROR_PARTIAL_CHAR
-        },
-        {
-            "%e1;",
-            "Recursive parameter entity not faulted",
-            NULL,
-            XML_ERROR_RECURSIVE_ENTITY_REF
-        },
-        { NULL, NULL, NULL, XML_ERROR_NONE }
-    };
-    int i;
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (! xcstrcmp(systemId, XCS("004-1.ent"))) {
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1), XML_TRUE)
+        == XML_STATUS_ERROR)
+      xml_failure(ext_parser);
+  } else if (! xcstrcmp(systemId, XCS("004-2.ent"))) {
+    ExtFaults *fault = (ExtFaults *)XML_GetUserData(parser);
+    enum XML_Status status;
+    enum XML_Error error;
 
-    for (i = 0; data_004_2[i].parse_text != NULL; i++) {
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_valuer);
-        XML_SetUserData(parser, &data_004_2[i]);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) == XML_STATUS_ERROR)
-            xml_failure(parser);
-        XML_ParserReset(parser, NULL);
+    status = _XML_Parse_SINGLE_BYTES(ext_parser, fault->parse_text,
+                                     (int)strlen(fault->parse_text), XML_TRUE);
+    if (fault->error == XML_ERROR_NONE) {
+      if (status == XML_STATUS_ERROR)
+        xml_failure(ext_parser);
+    } else {
+      if (status != XML_STATUS_ERROR)
+        fail(fault->fail_text);
+      error = XML_GetErrorCode(ext_parser);
+      if (error != fault->error
+          && (fault->error != XML_ERROR_XML_DECL
+              || error != XML_ERROR_TEXT_DECL))
+        xml_failure(ext_parser);
     }
+  }
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_external_entity_values) {
+  const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
+                     "<doc></doc>\n";
+  ExtFaults data_004_2[] = {
+      {"<!ATTLIST doc a1 CDATA 'value'>", NULL, NULL, XML_ERROR_NONE},
+      {"<!ATTLIST $doc a1 CDATA 'value'>", "Invalid token not faulted", NULL,
+       XML_ERROR_INVALID_TOKEN},
+      {"'wombat", "Unterminated string not faulted", NULL,
+       XML_ERROR_UNCLOSED_TOKEN},
+      {"\xe2\x82", "Partial UTF-8 character not faulted", NULL,
+       XML_ERROR_PARTIAL_CHAR},
+      {"<?xml version='1.0' encoding='utf-8'?>\n", NULL, NULL, XML_ERROR_NONE},
+      {"<?xml?>", "Malformed XML declaration not faulted", NULL,
+       XML_ERROR_XML_DECL},
+      {/* UTF-8 BOM */
+       "\xEF\xBB\xBF<!ATTLIST doc a1 CDATA 'value'>", NULL, NULL,
+       XML_ERROR_NONE},
+      {"<?xml version='1.0' encoding='utf-8'?>\n$",
+       "Invalid token after text declaration not faulted", NULL,
+       XML_ERROR_INVALID_TOKEN},
+      {"<?xml version='1.0' encoding='utf-8'?>\n'wombat",
+       "Unterminated string after text decl not faulted", NULL,
+       XML_ERROR_UNCLOSED_TOKEN},
+      {"<?xml version='1.0' encoding='utf-8'?>\n\xe2\x82",
+       "Partial UTF-8 character after text decl not faulted", NULL,
+       XML_ERROR_PARTIAL_CHAR},
+      {"%e1;", "Recursive parameter entity not faulted", NULL,
+       XML_ERROR_RECURSIVE_ENTITY_REF},
+      {NULL, NULL, NULL, XML_ERROR_NONE}};
+  int i;
+
+  for (i = 0; data_004_2[i].parse_text != NULL; i++) {
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_valuer);
+    XML_SetUserData(g_parser, &data_004_2[i]);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        == XML_STATUS_ERROR)
+      xml_failure(g_parser);
+    XML_ParserReset(g_parser, NULL);
+  }
 }
 END_TEST
 
 /* Test the recursive parse interacts with a not standalone handler */
 static int XMLCALL
-external_entity_not_standalone(XML_Parser parser,
-                               const XML_Char *context,
-                               const XML_Char *UNUSED_P(base),
-                               const XML_Char *systemId,
-                               const XML_Char *UNUSED_P(publicId))
-{
-    const char *text1 =
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e1 SYSTEM 'bar'>\n"
-        "%e1;\n";
-    const char *text2 = "<!ATTLIST doc a1 CDATA 'value'>";
-    XML_Parser ext_parser;
-
-    if (systemId == NULL)
-        return XML_STATUS_OK;
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (!xcstrcmp(systemId, XCS("foo"))) {
-        XML_SetNotStandaloneHandler(ext_parser,
-                                    reject_not_standalone_handler);
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            fail("Expected not standalone rejection");
-        if (XML_GetErrorCode(ext_parser) != XML_ERROR_NOT_STANDALONE)
-            xml_failure(ext_parser);
-        XML_SetNotStandaloneHandler(ext_parser, NULL);
-        XML_ParserFree(ext_parser);
-        return XML_STATUS_ERROR;
-    }
-    else if (!xcstrcmp(systemId, XCS("bar"))) {
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2),
-                                    XML_TRUE) == XML_STATUS_ERROR)
-            xml_failure(ext_parser);
-    }
-
-    XML_ParserFree(ext_parser);
+external_entity_not_standalone(XML_Parser parser, const XML_Char *context,
+                               const XML_Char *base, const XML_Char *systemId,
+                               const XML_Char *publicId) {
+  const char *text1 = "<!ELEMENT doc EMPTY>\n"
+                      "<!ENTITY % e1 SYSTEM 'bar'>\n"
+                      "%e1;\n";
+  const char *text2 = "<!ATTLIST doc a1 CDATA 'value'>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  if (systemId == NULL)
     return XML_STATUS_OK;
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (! xcstrcmp(systemId, XCS("foo"))) {
+    XML_SetNotStandaloneHandler(ext_parser, reject_not_standalone_handler);
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1), XML_TRUE)
+        != XML_STATUS_ERROR)
+      fail("Expected not standalone rejection");
+    if (XML_GetErrorCode(ext_parser) != XML_ERROR_NOT_STANDALONE)
+      xml_failure(ext_parser);
+    XML_SetNotStandaloneHandler(ext_parser, NULL);
+    XML_ParserFree(ext_parser);
+    return XML_STATUS_ERROR;
+  } else if (! xcstrcmp(systemId, XCS("bar"))) {
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2), XML_TRUE)
+        == XML_STATUS_ERROR)
+      xml_failure(ext_parser);
+  }
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_ext_entity_not_standalone)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc></doc>";
+START_TEST(test_ext_entity_not_standalone) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc></doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_not_standalone);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Standalone rejection not caught");
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_not_standalone);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Standalone rejection not caught");
 }
 END_TEST
 
 static int XMLCALL
-external_entity_value_aborter(XML_Parser parser,
-                              const XML_Char *context,
-                              const XML_Char *UNUSED_P(base),
-                              const XML_Char *systemId,
-                              const XML_Char *UNUSED_P(publicId))
-{
-    const char *text1 =
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
-        "<!ENTITY % e2 '%e1;'>\n"
-        "%e1;\n";
-    const char *text2 =
-        "<?xml version='1.0' encoding='utf-8'?>";
-    XML_Parser ext_parser;
-
-    if (systemId == NULL)
-        return XML_STATUS_OK;
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-    if (!xcstrcmp(systemId, XCS("004-1.ent"))) {
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1),
-                                    XML_TRUE) == XML_STATUS_ERROR)
-            xml_failure(ext_parser);
-    }
-    if (!xcstrcmp(systemId, XCS("004-2.ent"))) {
-        XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
-        XML_SetUserData(ext_parser, ext_parser);
-        if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            fail("Aborted parse not faulted");
-        if (XML_GetErrorCode(ext_parser) != XML_ERROR_ABORTED)
-            xml_failure(ext_parser);
-    }
-
-    XML_ParserFree(ext_parser);
+external_entity_value_aborter(XML_Parser parser, const XML_Char *context,
+                              const XML_Char *base, const XML_Char *systemId,
+                              const XML_Char *publicId) {
+  const char *text1 = "<!ELEMENT doc EMPTY>\n"
+                      "<!ENTITY % e1 SYSTEM '004-2.ent'>\n"
+                      "<!ENTITY % e2 '%e1;'>\n"
+                      "%e1;\n";
+  const char *text2 = "<?xml version='1.0' encoding='utf-8'?>";
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  if (systemId == NULL)
     return XML_STATUS_OK;
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+  if (! xcstrcmp(systemId, XCS("004-1.ent"))) {
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text1, (int)strlen(text1), XML_TRUE)
+        == XML_STATUS_ERROR)
+      xml_failure(ext_parser);
+  }
+  if (! xcstrcmp(systemId, XCS("004-2.ent"))) {
+    XML_SetXmlDeclHandler(ext_parser, entity_suspending_xdecl_handler);
+    XML_SetUserData(ext_parser, ext_parser);
+    if (_XML_Parse_SINGLE_BYTES(ext_parser, text2, (int)strlen(text2), XML_TRUE)
+        != XML_STATUS_ERROR)
+      fail("Aborted parse not faulted");
+    if (XML_GetErrorCode(ext_parser) != XML_ERROR_ABORTED)
+      xml_failure(ext_parser);
+  }
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_ext_entity_value_abort)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
-        "<doc></doc>\n";
+START_TEST(test_ext_entity_value_abort) {
+  const char *text = "<!DOCTYPE doc SYSTEM '004-1.ent'>\n"
+                     "<doc></doc>\n";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_value_aborter);
-    resumable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_value_aborter);
+  resumable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_bad_public_doctype)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<!DOCTYPE doc PUBLIC '{BadName}' 'test'>\n"
-        "<doc></doc>";
+START_TEST(test_bad_public_doctype) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<!DOCTYPE doc PUBLIC '{BadName}' 'test'>\n"
+                     "<doc></doc>";
 
-    /* Setting a handler provokes a particular code path */
-    XML_SetDoctypeDeclHandler(parser,
-                              dummy_start_doctype_handler,
-                              dummy_end_doctype_handler);
-    expect_failure(text, XML_ERROR_PUBLICID, "Bad Public ID not failed");
+  /* Setting a handler provokes a particular code path */
+  XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_handler,
+                            dummy_end_doctype_handler);
+  expect_failure(text, XML_ERROR_PUBLICID, "Bad Public ID not failed");
 }
 END_TEST
 
 /* Test based on ibm/valid/P32/ibm32v04.xml */
-START_TEST(test_attribute_enum_value)
-{
-    const char *text =
-        "<?xml version='1.0' standalone='no'?>\n"
-        "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
-        "<animal>This is a \n    <a/>  \n\nyellow tiger</animal>";
-    ExtTest dtd_data = {
-        "<!ELEMENT animal (#PCDATA|a)*>\n"
-        "<!ELEMENT a EMPTY>\n"
-        "<!ATTLIST animal xml:space (default|preserve) 'preserve'>",
-        NULL,
-        NULL
-    };
-    const XML_Char *expected = XCS("This is a \n      \n\nyellow tiger");
-
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetUserData(parser, &dtd_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    /* An attribute list handler provokes a different code path */
-    XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-    run_ext_character_check(text, &dtd_data, expected);
+START_TEST(test_attribute_enum_value) {
+  const char *text = "<?xml version='1.0' standalone='no'?>\n"
+                     "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
+                     "<animal>This is a \n    <a/>  \n\nyellow tiger</animal>";
+  ExtTest dtd_data
+      = {"<!ELEMENT animal (#PCDATA|a)*>\n"
+         "<!ELEMENT a EMPTY>\n"
+         "<!ATTLIST animal xml:space (default|preserve) 'preserve'>",
+         NULL, NULL};
+  const XML_Char *expected = XCS("This is a \n      \n\nyellow tiger");
+
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetUserData(g_parser, &dtd_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  /* An attribute list handler provokes a different code path */
+  XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+  run_ext_character_check(text, &dtd_data, expected);
 }
 END_TEST
 
@@ -4837,69 +4448,61 @@ END_TEST
  * language of the XML 1.0 spec is somewhat unhelpful as to what ought
  * to happen, so this is currently treated as acceptable.
  */
-START_TEST(test_predefined_entity_redefinition)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY apos 'foo'>\n"
-        "]>\n"
-        "<doc>&apos;</doc>";
-    run_character_check(text, XCS("'"));
+START_TEST(test_predefined_entity_redefinition) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY apos 'foo'>\n"
+                     "]>\n"
+                     "<doc>&apos;</doc>";
+  run_character_check(text, XCS("'"));
 }
 END_TEST
 
 /* Test that the parser stops processing the DTD after an unresolved
  * parameter entity is encountered.
  */
-START_TEST(test_dtd_stop_processing)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "%foo;\n"
-        "<!ENTITY bar 'bas'>\n"
-        "]><doc/>";
+START_TEST(test_dtd_stop_processing) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "%foo;\n"
+                     "<!ENTITY bar 'bas'>\n"
+                     "]><doc/>";
 
-    XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-    dummy_handler_flags = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (dummy_handler_flags != 0)
-        fail("DTD processing still going after undefined PE");
+  XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+  dummy_handler_flags = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (dummy_handler_flags != 0)
+    fail("DTD processing still going after undefined PE");
 }
 END_TEST
 
 /* Test public notations with no system ID */
-START_TEST(test_public_notation_no_sysid)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!NOTATION note PUBLIC 'foo'>\n"
-        "<!ELEMENT doc EMPTY>\n"
-        "]>\n<doc/>";
+START_TEST(test_public_notation_no_sysid) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!NOTATION note PUBLIC 'foo'>\n"
+                     "<!ELEMENT doc EMPTY>\n"
+                     "]>\n<doc/>";
 
-    dummy_handler_flags = 0;
-    XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
-        fail("Notation declaration handler not called");
+  dummy_handler_flags = 0;
+  XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
+    fail("Notation declaration handler not called");
 }
 END_TEST
 
 static void XMLCALL
-record_element_start_handler(void *userData,
-                             const XML_Char *name,
-                             const XML_Char **UNUSED_P(atts))
-{
-    CharData_AppendXMLChars((CharData *)userData, name, (int)xcstrlen(name));
+record_element_start_handler(void *userData, const XML_Char *name,
+                             const XML_Char **atts) {
+  UNUSED_P(atts);
+  CharData_AppendXMLChars((CharData *)userData, name, (int)xcstrlen(name));
 }
 
-START_TEST(test_nested_groups)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_nested_groups) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ELEMENT doc "
         /* Sixteen elements per line */
         "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
@@ -4908,363 +4511,330 @@ START_TEST(test_nested_groups)
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    XML_SetStartElementHandler(parser, record_element_start_handler);
-    XML_SetUserData(parser, &storage);
-    dummy_handler_flags = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS("doce"));
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler not fired");
-}
-END_TEST
-
-START_TEST(test_group_choice)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc (a|b|c)+>\n"
-        "<!ELEMENT a EMPTY>\n"
-        "<!ELEMENT b (#PCDATA)>\n"
-        "<!ELEMENT c ANY>\n"
-        "]>\n"
-        "<doc>\n"
-        "<a/>\n"
-        "<b attr='foo'>This is a foo</b>\n"
-        "<c></c>\n"
-        "</doc>\n";
-
-    XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-    dummy_handler_flags = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler flag not raised");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  XML_SetStartElementHandler(g_parser, record_element_start_handler);
+  XML_SetUserData(g_parser, &storage);
+  dummy_handler_flags = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS("doce"));
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler not fired");
+}
+END_TEST
+
+START_TEST(test_group_choice) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ELEMENT doc (a|b|c)+>\n"
+                     "<!ELEMENT a EMPTY>\n"
+                     "<!ELEMENT b (#PCDATA)>\n"
+                     "<!ELEMENT c ANY>\n"
+                     "]>\n"
+                     "<doc>\n"
+                     "<a/>\n"
+                     "<b attr='foo'>This is a foo</b>\n"
+                     "<c></c>\n"
+                     "</doc>\n";
+
+  XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+  dummy_handler_flags = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler flag not raised");
 }
 END_TEST
 
 static int XMLCALL
-external_entity_public(XML_Parser parser,
-                       const XML_Char *context,
-                       const XML_Char *UNUSED_P(base),
-                       const XML_Char *systemId,
-                       const XML_Char *publicId)
-{
-    const char *text1 = (const char *)XML_GetUserData(parser);
-    const char *text2 = "<!ATTLIST doc a CDATA 'value'>";
-    const char *text = NULL;
-    XML_Parser ext_parser;
-    int parse_res;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        return XML_STATUS_ERROR;
-    if (systemId != NULL && !xcstrcmp(systemId, XCS("http://example.org/"))) {
-        text = text1;
-    }
-    else if (publicId != NULL && !xcstrcmp(publicId, XCS("foo"))) {
-        text = text2;
-    }
-    else
-        fail("Unexpected parameters to external entity parser");
-    parse_res = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                   XML_TRUE);
-    XML_ParserFree(ext_parser);
-    return parse_res;
-}
-
-START_TEST(test_standalone_parameter_entity)
-{
-    const char *text =
-        "<?xml version='1.0' standalone='yes'?>\n"
-        "<!DOCTYPE doc SYSTEM 'http://example.org/' [\n"
-        "<!ENTITY % entity '<!ELEMENT doc (#PCDATA)>'>\n"
-        "%entity;\n"
-        "]>\n"
-        "<doc></doc>";
-    char dtd_data[] =
-        "<!ENTITY % e1 'foo'>\n";
-
-    XML_SetUserData(parser, dtd_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_public);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+external_entity_public(XML_Parser parser, const XML_Char *context,
+                       const XML_Char *base, const XML_Char *systemId,
+                       const XML_Char *publicId) {
+  const char *text1 = (const char *)XML_GetUserData(parser);
+  const char *text2 = "<!ATTLIST doc a CDATA 'value'>";
+  const char *text = NULL;
+  XML_Parser ext_parser;
+  int parse_res;
+
+  UNUSED_P(base);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    return XML_STATUS_ERROR;
+  if (systemId != NULL && ! xcstrcmp(systemId, XCS("http://example.org/"))) {
+    text = text1;
+  } else if (publicId != NULL && ! xcstrcmp(publicId, XCS("foo"))) {
+    text = text2;
+  } else
+    fail("Unexpected parameters to external entity parser");
+  assert(text != NULL);
+  parse_res
+      = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE);
+  XML_ParserFree(ext_parser);
+  return parse_res;
+}
+
+START_TEST(test_standalone_parameter_entity) {
+  const char *text = "<?xml version='1.0' standalone='yes'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'http://example.org/' [\n"
+                     "<!ENTITY % entity '<!ELEMENT doc (#PCDATA)>'>\n"
+                     "%entity;\n"
+                     "]>\n"
+                     "<doc></doc>";
+  char dtd_data[] = "<!ENTITY % e1 'foo'>\n";
+
+  XML_SetUserData(g_parser, dtd_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test skipping of parameter entity in an external DTD */
 /* Derived from ibm/invalid/P69/ibm69i01.xml */
-START_TEST(test_skipped_parameter_entity)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
-        "<!ELEMENT root (#PCDATA|a)* >\n"
-        "]>\n"
-        "<root></root>";
-    ExtTest dtd_data = { "%pe2;", NULL, NULL };
-
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetUserData(parser, &dtd_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetSkippedEntityHandler(parser, dummy_skip_handler);
-    dummy_handler_flags = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (dummy_handler_flags != DUMMY_SKIP_HANDLER_FLAG)
-        fail("Skip handler not executed");
+START_TEST(test_skipped_parameter_entity) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
+                     "<!ELEMENT root (#PCDATA|a)* >\n"
+                     "]>\n"
+                     "<root></root>";
+  ExtTest dtd_data = {"%pe2;", NULL, NULL};
+
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetUserData(g_parser, &dtd_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetSkippedEntityHandler(g_parser, dummy_skip_handler);
+  dummy_handler_flags = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (dummy_handler_flags != DUMMY_SKIP_HANDLER_FLAG)
+    fail("Skip handler not executed");
 }
 END_TEST
 
 /* Test recursive parameter entity definition rejected in external DTD */
-START_TEST(test_recursive_external_parameter_entity)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
-        "<!ELEMENT root (#PCDATA|a)* >\n"
-        "]>\n"
-        "<root></root>";
-    ExtFaults dtd_data = {
-        "<!ENTITY % pe2 '&#37;pe2;'>\n%pe2;",
-        "Recursive external parameter entity not faulted",
-        NULL,
-        XML_ERROR_RECURSIVE_ENTITY_REF
-    };
+START_TEST(test_recursive_external_parameter_entity) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<!DOCTYPE root SYSTEM 'http://example.org/dtd.ent' [\n"
+                     "<!ELEMENT root (#PCDATA|a)* >\n"
+                     "]>\n"
+                     "<root></root>";
+  ExtFaults dtd_data = {"<!ENTITY % pe2 '&#37;pe2;'>\n%pe2;",
+                        "Recursive external parameter entity not faulted", NULL,
+                        XML_ERROR_RECURSIVE_ENTITY_REF};
 
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    XML_SetUserData(parser, &dtd_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    expect_failure(text,
-                   XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Recursive external parameter not spotted");
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  XML_SetUserData(g_parser, &dtd_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Recursive external parameter not spotted");
 }
 END_TEST
 
 /* Test undefined parameter entity in external entity handler */
 static int XMLCALL
-external_entity_devaluer(XML_Parser parser,
-                         const XML_Char *context,
-                         const XML_Char *UNUSED_P(base),
-                         const XML_Char *systemId,
-                         const XML_Char *UNUSED_P(publicId))
-{
-    const char *text =
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e1 SYSTEM 'bar'>\n"
-        "%e1;\n";
-    XML_Parser ext_parser;
-    intptr_t clear_handler = (intptr_t)XML_GetUserData(parser);
-
-    if (systemId == NULL || !xcstrcmp(systemId, XCS("bar")))
-        return XML_STATUS_OK;
-    if (xcstrcmp(systemId, XCS("foo")))
-        fail("Unexpected system ID");
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could note create external entity parser");
-    if (clear_handler)
-        XML_SetExternalEntityRefHandler(ext_parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(ext_parser);
-
-    XML_ParserFree(ext_parser);
+external_entity_devaluer(XML_Parser parser, const XML_Char *context,
+                         const XML_Char *base, const XML_Char *systemId,
+                         const XML_Char *publicId) {
+  const char *text = "<!ELEMENT doc EMPTY>\n"
+                     "<!ENTITY % e1 SYSTEM 'bar'>\n"
+                     "%e1;\n";
+  XML_Parser ext_parser;
+  intptr_t clear_handler = (intptr_t)XML_GetUserData(parser);
+
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  if (systemId == NULL || ! xcstrcmp(systemId, XCS("bar")))
     return XML_STATUS_OK;
-}
-
-START_TEST(test_undefined_ext_entity_in_external_dtd)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc></doc>\n";
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_devaluer);
-    XML_SetUserData(parser, (void *)(intptr_t)XML_FALSE);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    /* Now repeat without the external entity ref handler invoking
-     * another copy of itself.
-     */
-    XML_ParserReset(parser, NULL);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_devaluer);
-    XML_SetUserData(parser, (void *)(intptr_t)XML_TRUE);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (xcstrcmp(systemId, XCS("foo")))
+    fail("Unexpected system ID");
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could note create external entity parser");
+  if (clear_handler)
+    XML_SetExternalEntityRefHandler(ext_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(ext_parser);
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_undefined_ext_entity_in_external_dtd) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc></doc>\n";
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_devaluer);
+  XML_SetUserData(g_parser, (void *)(intptr_t)XML_FALSE);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  /* Now repeat without the external entity ref handler invoking
+   * another copy of itself.
+   */
+  XML_ParserReset(g_parser, NULL);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_devaluer);
+  XML_SetUserData(g_parser, (void *)(intptr_t)XML_TRUE);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
 static void XMLCALL
-aborting_xdecl_handler(void           *UNUSED_P(userData),
-                       const XML_Char *UNUSED_P(version),
-                       const XML_Char *UNUSED_P(encoding),
-                       int             UNUSED_P(standalone))
-{
-    XML_StopParser(parser, resumable);
-    XML_SetXmlDeclHandler(parser, NULL);
+aborting_xdecl_handler(void *userData, const XML_Char *version,
+                       const XML_Char *encoding, int standalone) {
+  UNUSED_P(userData);
+  UNUSED_P(version);
+  UNUSED_P(encoding);
+  UNUSED_P(standalone);
+  XML_StopParser(g_parser, resumable);
+  XML_SetXmlDeclHandler(g_parser, NULL);
 }
 
 /* Test suspending the parse on receiving an XML declaration works */
-START_TEST(test_suspend_xdecl)
-{
-    const char *text = long_character_data_text;
+START_TEST(test_suspend_xdecl) {
+  const char *text = long_character_data_text;
 
-    XML_SetXmlDeclHandler(parser, aborting_xdecl_handler);
-    resumable = XML_TRUE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
-        xml_failure(parser);
-    /* Attempt to start a new parse while suspended */
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Attempt to parse while suspended not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_SUSPENDED)
-        fail("Suspended parse not faulted with correct error");
+  XML_SetXmlDeclHandler(g_parser, aborting_xdecl_handler);
+  resumable = XML_TRUE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
+    xml_failure(g_parser);
+  /* Attempt to start a new parse while suspended */
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Attempt to parse while suspended not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
+    fail("Suspended parse not faulted with correct error");
 }
 END_TEST
 
 /* Test aborting the parse in an epilog works */
 static void XMLCALL
-selective_aborting_default_handler(void *userData,
-                                   const XML_Char *s,
-                                   int len)
-{
-    const XML_Char *match = (const XML_Char *)userData;
-
-    if (match == NULL ||
-        (xcstrlen(match) == (unsigned)len &&
-         !xcstrncmp(match, s, len))) {
-        XML_StopParser(parser, resumable);
-        XML_SetDefaultHandler(parser, NULL);
-    }
+selective_aborting_default_handler(void *userData, const XML_Char *s, int len) {
+  const XML_Char *match = (const XML_Char *)userData;
+
+  if (match == NULL
+      || (xcstrlen(match) == (unsigned)len && ! xcstrncmp(match, s, len))) {
+    XML_StopParser(g_parser, resumable);
+    XML_SetDefaultHandler(g_parser, NULL);
+  }
 }
 
-START_TEST(test_abort_epilog)
-{
-    const char *text = "<doc></doc>\n\r\n";
-    XML_Char match[] = XCS("\r");
+START_TEST(test_abort_epilog) {
+  const char *text = "<doc></doc>\n\r\n";
+  XML_Char match[] = XCS("\r");
 
-    XML_SetDefaultHandler(parser, selective_aborting_default_handler);
-    XML_SetUserData(parser, match);
-    resumable = XML_FALSE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Abort not triggered");
-    if (XML_GetErrorCode(parser) != XML_ERROR_ABORTED)
-        xml_failure(parser);
+  XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
+  XML_SetUserData(g_parser, match);
+  resumable = XML_FALSE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Abort not triggered");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_ABORTED)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test a different code path for abort in the epilog */
-START_TEST(test_abort_epilog_2)
-{
-    const char *text = "<doc></doc>\n";
-    XML_Char match[] = XCS("\n");
+START_TEST(test_abort_epilog_2) {
+  const char *text = "<doc></doc>\n";
+  XML_Char match[] = XCS("\n");
 
-    XML_SetDefaultHandler(parser, selective_aborting_default_handler);
-    XML_SetUserData(parser, match);
-    resumable = XML_FALSE;
-    expect_failure(text, XML_ERROR_ABORTED, "Abort not triggered");
+  XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
+  XML_SetUserData(g_parser, match);
+  resumable = XML_FALSE;
+  expect_failure(text, XML_ERROR_ABORTED, "Abort not triggered");
 }
 END_TEST
 
 /* Test suspension from the epilog */
-START_TEST(test_suspend_epilog)
-{
-    const char *text = "<doc></doc>\n";
-    XML_Char match[] = XCS("\n");
+START_TEST(test_suspend_epilog) {
+  const char *text = "<doc></doc>\n";
+  XML_Char match[] = XCS("\n");
 
-    XML_SetDefaultHandler(parser, selective_aborting_default_handler);
-    XML_SetUserData(parser, match);
-    resumable = XML_TRUE;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
+  XML_SetDefaultHandler(g_parser, selective_aborting_default_handler);
+  XML_SetUserData(g_parser, match);
+  resumable = XML_TRUE;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
 }
 END_TEST
 
 static void XMLCALL
-suspending_end_handler(void *userData,
-                       const XML_Char *UNUSED_P(s))
-{
-    XML_StopParser((XML_Parser)userData, 1);
+suspending_end_handler(void *userData, const XML_Char *s) {
+  UNUSED_P(s);
+  XML_StopParser((XML_Parser)userData, 1);
 }
 
-START_TEST(test_suspend_in_sole_empty_tag)
-{
-    const char *text = "<doc/>";
-    enum XML_Status rc;
+START_TEST(test_suspend_in_sole_empty_tag) {
+  const char *text = "<doc/>";
+  enum XML_Status rc;
 
-    XML_SetEndElementHandler(parser, suspending_end_handler);
-    XML_SetUserData(parser, parser);
-    rc = _XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                 XML_TRUE);
-    if (rc == XML_STATUS_ERROR)
-        xml_failure(parser);
-    else if (rc != XML_STATUS_SUSPENDED)
-        fail("Suspend not triggered");
-    rc = XML_ResumeParser(parser);
-    if (rc == XML_STATUS_ERROR)
-        xml_failure(parser);
-    else if (rc != XML_STATUS_OK)
-        fail("Resume failed");
+  XML_SetEndElementHandler(g_parser, suspending_end_handler);
+  XML_SetUserData(g_parser, g_parser);
+  rc = _XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE);
+  if (rc == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  else if (rc != XML_STATUS_SUSPENDED)
+    fail("Suspend not triggered");
+  rc = XML_ResumeParser(g_parser);
+  if (rc == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  else if (rc != XML_STATUS_OK)
+    fail("Resume failed");
 }
 END_TEST
 
-START_TEST(test_unfinished_epilog)
-{
-    const char *text = "<doc></doc><";
+START_TEST(test_unfinished_epilog) {
+  const char *text = "<doc></doc><";
 
-    expect_failure(text, XML_ERROR_UNCLOSED_TOKEN,
-                   "Incomplete epilog entry not faulted");
+  expect_failure(text, XML_ERROR_UNCLOSED_TOKEN,
+                 "Incomplete epilog entry not faulted");
 }
 END_TEST
 
-START_TEST(test_partial_char_in_epilog)
-{
-    const char *text = "<doc></doc>\xe2\x82";
+START_TEST(test_partial_char_in_epilog) {
+  const char *text = "<doc></doc>\xe2\x82";
 
-    /* First check that no fault is raised if the parse is not finished */
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    /* Now check that it is faulted once we finish */
-    if (XML_ParseBuffer(parser, 0, XML_TRUE) != XML_STATUS_ERROR)
-        fail("Partial character in epilog not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_PARTIAL_CHAR)
-        xml_failure(parser);
+  /* First check that no fault is raised if the parse is not finished */
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  /* Now check that it is faulted once we finish */
+  if (XML_ParseBuffer(g_parser, 0, XML_TRUE) != XML_STATUS_ERROR)
+    fail("Partial character in epilog not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_PARTIAL_CHAR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_hash_collision)
-{
-    /* For full coverage of the lookup routine, we need to ensure a
-     * hash collision even though we can only tell that we have one
-     * through breakpoint debugging or coverage statistics.  The
-     * following will cause a hash collision on machines with a 64-bit
-     * long type; others will have to experiment.  The full coverage
-     * tests invoked from qa.sh usually provide a hash collision, but
-     * not always.  This is an attempt to provide insurance.
-     */
+START_TEST(test_hash_collision) {
+  /* For full coverage of the lookup routine, we need to ensure a
+   * hash collision even though we can only tell that we have one
+   * through breakpoint debugging or coverage statistics.  The
+   * following will cause a hash collision on machines with a 64-bit
+   * long type; others will have to experiment.  The full coverage
+   * tests invoked from qa.sh usually provide a hash collision, but
+   * not always.  This is an attempt to provide insurance.
+   */
 #define COLLIDING_HASH_SALT (unsigned long)_SIP_ULL(0xffffffffU, 0xff99fc90U)
-    const char * text =
-        "<doc>\n"
+  const char *text
+      = "<doc>\n"
         "<a1/><a2/><a3/><a4/><a5/><a6/><a7/><a8/>\n"
         "<b1></b1><b2 attr='foo'>This is a foo</b2><b3></b3><b4></b4>\n"
         "<b5></b5><b6></b6><b7></b7><b8></b8>\n"
@@ -5273,575 +4843,524 @@ START_TEST(test_hash_collision)
         "<d8>This triggers the table growth and collides with b2</d8>\n"
         "</doc>\n";
 
-    XML_SetHashSalt(parser, COLLIDING_HASH_SALT);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetHashSalt(g_parser, COLLIDING_HASH_SALT);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 #undef COLLIDING_HASH_SALT
 
 /* Test resuming a parse suspended in entity substitution */
 static void XMLCALL
-start_element_suspender(void *UNUSED_P(userData),
-                        const XML_Char *name,
-                        const XML_Char **UNUSED_P(atts))
-{
-    if (!xcstrcmp(name, XCS("suspend")))
-        XML_StopParser(parser, XML_TRUE);
-    if (!xcstrcmp(name, XCS("abort")))
-        XML_StopParser(parser, XML_FALSE);
-}
-
-START_TEST(test_suspend_resume_internal_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+start_element_suspender(void *userData, const XML_Char *name,
+                        const XML_Char **atts) {
+  UNUSED_P(userData);
+  UNUSED_P(atts);
+  if (! xcstrcmp(name, XCS("suspend")))
+    XML_StopParser(g_parser, XML_TRUE);
+  if (! xcstrcmp(name, XCS("abort")))
+    XML_StopParser(g_parser, XML_FALSE);
+}
+
+START_TEST(test_suspend_resume_internal_entity) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ENTITY foo '<suspend>Hi<suspend>Ho</suspend></suspend>'>\n"
         "]>\n"
         "<doc>&foo;</doc>\n";
-    const XML_Char *expected1 = XCS("Hi");
-    const XML_Char *expected2 = XCS("HiHo");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetStartElementHandler(parser, start_element_suspender);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    XML_SetUserData(parser, &storage);
-    if (XML_Parse(parser, text, (int)strlen(text),
-                  XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS(""));
-    if (XML_ResumeParser(parser) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected1);
-    if (XML_ResumeParser(parser) != XML_STATUS_OK)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected2);
+  const XML_Char *expected1 = XCS("Hi");
+  const XML_Char *expected2 = XCS("HiHo");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetStartElementHandler(g_parser, start_element_suspender);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS(""));
+  if (XML_ResumeParser(g_parser) != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected1);
+  if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected2);
 }
 END_TEST
 
 /* Test syntax error is caught at parse resumption */
-START_TEST(test_resume_entity_with_syntax_error)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY foo '<suspend>Hi</wombat>'>\n"
-        "]>\n"
-        "<doc>&foo;</doc>\n";
+START_TEST(test_resume_entity_with_syntax_error) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY foo '<suspend>Hi</wombat>'>\n"
+                     "]>\n"
+                     "<doc>&foo;</doc>\n";
 
-    XML_SetStartElementHandler(parser, start_element_suspender);
-    if (XML_Parse(parser, text, (int)strlen(text),
-                  XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    if (XML_ResumeParser(parser) != XML_STATUS_ERROR)
-        fail("Syntax error in entity not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_TAG_MISMATCH)
-        xml_failure(parser);
+  XML_SetStartElementHandler(g_parser, start_element_suspender);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  if (XML_ResumeParser(g_parser) != XML_STATUS_ERROR)
+    fail("Syntax error in entity not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_TAG_MISMATCH)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test suspending and resuming in a parameter entity substitution */
 static void XMLCALL
-element_decl_suspender(void *UNUSED_P(userData),
-                       const XML_Char *UNUSED_P(name),
-                       XML_Content *model)
-{
-    XML_StopParser(parser, XML_TRUE);
-    XML_FreeContentModel(parser, model);
-}
-
-START_TEST(test_suspend_resume_parameter_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY % foo '<!ELEMENT doc (#PCDATA)*>'>\n"
-        "%foo;\n"
-        "]>\n"
-        "<doc>Hello, world</doc>";
-    const XML_Char *expected = XCS("Hello, world");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetElementDeclHandler(parser, element_decl_suspender);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    XML_SetUserData(parser, &storage);
-    if (XML_Parse(parser, text, (int)strlen(text),
-                  XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, XCS(""));
-    if (XML_ResumeParser(parser) != XML_STATUS_OK)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+element_decl_suspender(void *userData, const XML_Char *name,
+                       XML_Content *model) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  XML_StopParser(g_parser, XML_TRUE);
+  XML_FreeContentModel(g_parser, model);
+}
+
+START_TEST(test_suspend_resume_parameter_entity) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY % foo '<!ELEMENT doc (#PCDATA)*>'>\n"
+                     "%foo;\n"
+                     "]>\n"
+                     "<doc>Hello, world</doc>";
+  const XML_Char *expected = XCS("Hello, world");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetElementDeclHandler(g_parser, element_decl_suspender);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, XCS(""));
+  if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test attempting to use parser after an error is faulted */
-START_TEST(test_restart_on_error)
-{
-    const char *text = "<$doc><doc></doc>";
+START_TEST(test_restart_on_error) {
+  const char *text = "<$doc><doc></doc>";
 
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Invalid tag name not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
-        xml_failure(parser);
-    if (XML_Parse(parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
-        fail("Restarting invalid parse not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
-        xml_failure(parser);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Invalid tag name not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
+    xml_failure(g_parser);
+  if (XML_Parse(g_parser, NULL, 0, XML_TRUE) != XML_STATUS_ERROR)
+    fail("Restarting invalid parse not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_INVALID_TOKEN)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that angle brackets in an attribute default value are faulted */
-START_TEST(test_reject_lt_in_attribute_value)
-{
-    const char *text =
-        "<!DOCTYPE doc [<!ATTLIST doc a CDATA '<bar>'>]>\n"
-        "<doc></doc>";
+START_TEST(test_reject_lt_in_attribute_value) {
+  const char *text = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '<bar>'>]>\n"
+                     "<doc></doc>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Bad attribute default not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Bad attribute default not faulted");
 }
 END_TEST
 
-START_TEST(test_reject_unfinished_param_in_att_value)
-{
-    const char *text =
-        "<!DOCTYPE doc [<!ATTLIST doc a CDATA '&foo'>]>\n"
-        "<doc></doc>";
+START_TEST(test_reject_unfinished_param_in_att_value) {
+  const char *text = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '&foo'>]>\n"
+                     "<doc></doc>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Bad attribute default not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Bad attribute default not faulted");
 }
 END_TEST
 
-START_TEST(test_trailing_cr_in_att_value)
-{
-    const char *text = "<doc a='value\r'/>";
+START_TEST(test_trailing_cr_in_att_value) {
+  const char *text = "<doc a='value\r'/>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Try parsing a general entity within a parameter entity in a
  * standalone internal DTD.  Covers a corner case in the parser.
  */
-START_TEST(test_standalone_internal_entity)
-{
-    const char *text =
-        "<?xml version='1.0' standalone='yes' ?>\n"
-        "<!DOCTYPE doc [\n"
-        "  <!ELEMENT doc (#PCDATA)>\n"
-        "  <!ENTITY % pe '<!ATTLIST doc att2 CDATA \"&ge;\">'>\n"
-        "  <!ENTITY ge 'AttDefaultValue'>\n"
-        "  %pe;\n"
-        "]>\n"
-        "<doc att2='any'/>";
+START_TEST(test_standalone_internal_entity) {
+  const char *text = "<?xml version='1.0' standalone='yes' ?>\n"
+                     "<!DOCTYPE doc [\n"
+                     "  <!ELEMENT doc (#PCDATA)>\n"
+                     "  <!ENTITY % pe '<!ATTLIST doc att2 CDATA \"&ge;\">'>\n"
+                     "  <!ENTITY ge 'AttDefaultValue'>\n"
+                     "  %pe;\n"
+                     "]>\n"
+                     "<doc att2='any'/>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that a reference to an unknown external entity is skipped */
-START_TEST(test_skipped_external_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc></doc>\n";
-    ExtTest test_data = {
-        "<!ELEMENT doc EMPTY>\n"
-        "<!ENTITY % e2 '%e1;'>\n",
-        NULL,
-        NULL
-    };
+START_TEST(test_skipped_external_entity) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc></doc>\n";
+  ExtTest test_data = {"<!ELEMENT doc EMPTY>\n"
+                       "<!ENTITY % e2 '%e1;'>\n",
+                       NULL, NULL};
 
-    XML_SetUserData(parser, &test_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test a different form of unknown external entity */
 typedef struct ext_hdlr_data {
-    const char *parse_text;
-    XML_ExternalEntityRefHandler handler;
+  const char *parse_text;
+  XML_ExternalEntityRefHandler handler;
 } ExtHdlrData;
 
 static int XMLCALL
-external_entity_oneshot_loader(XML_Parser parser,
-                               const XML_Char *context,
-                               const XML_Char *UNUSED_P(base),
-                               const XML_Char *UNUSED_P(systemId),
-                               const XML_Char *UNUSED_P(publicId))
-{
-    ExtHdlrData *test_data = (ExtHdlrData *)XML_GetUserData(parser);
-    XML_Parser ext_parser;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser.");
-    /* Use the requested entity parser for further externals */
-    XML_SetExternalEntityRefHandler(ext_parser, test_data->handler);
-    if ( _XML_Parse_SINGLE_BYTES(ext_parser,
-                                 test_data->parse_text,
-                                 (int)strlen(test_data->parse_text),
-                                 XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(ext_parser);
-    }
-
-    XML_ParserFree(ext_parser);
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_skipped_null_loaded_ext_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
-        "<doc />";
-    ExtHdlrData test_data = {
-        "<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
-        "<!ENTITY % pe2 '%pe1;'>\n"
-        "%pe2;\n",
-        external_entity_null_loader
-    };
-
-    XML_SetUserData(parser, &test_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_oneshot_loader);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-}
-END_TEST
-
-START_TEST(test_skipped_unloaded_ext_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
-        "<doc />";
-    ExtHdlrData test_data = {
-        "<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
-        "<!ENTITY % pe2 '%pe1;'>\n"
-        "%pe2;\n",
-        NULL
-    };
-
-    XML_SetUserData(parser, &test_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_oneshot_loader);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+external_entity_oneshot_loader(XML_Parser parser, const XML_Char *context,
+                               const XML_Char *base, const XML_Char *systemId,
+                               const XML_Char *publicId) {
+  ExtHdlrData *test_data = (ExtHdlrData *)XML_GetUserData(parser);
+  XML_Parser ext_parser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser.");
+  /* Use the requested entity parser for further externals */
+  XML_SetExternalEntityRefHandler(ext_parser, test_data->handler);
+  if (_XML_Parse_SINGLE_BYTES(ext_parser, test_data->parse_text,
+                              (int)strlen(test_data->parse_text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(ext_parser);
+  }
+
+  XML_ParserFree(ext_parser);
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_skipped_null_loaded_ext_entity) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
+                     "<doc />";
+  ExtHdlrData test_data
+      = {"<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
+         "<!ENTITY % pe2 '%pe1;'>\n"
+         "%pe2;\n",
+         external_entity_null_loader};
+
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_oneshot_loader);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+}
+END_TEST
+
+START_TEST(test_skipped_unloaded_ext_entity) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
+                     "<doc />";
+  ExtHdlrData test_data
+      = {"<!ENTITY % pe1 SYSTEM 'http://example.org/two.ent'>\n"
+         "<!ENTITY % pe2 '%pe1;'>\n"
+         "%pe2;\n",
+         NULL};
+
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_oneshot_loader);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that a parameter entity value ending with a carriage return
  * has it translated internally into a newline.
  */
-START_TEST(test_param_entity_with_trailing_cr)
-{
+START_TEST(test_param_entity_with_trailing_cr) {
 #define PARAM_ENTITY_NAME "pe"
 #define PARAM_ENTITY_CORE_VALUE "<!ATTLIST doc att CDATA \"default\">"
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc/>";
-    ExtTest test_data = {
-        "<!ENTITY % " PARAM_ENTITY_NAME
-        " '" PARAM_ENTITY_CORE_VALUE "\r'>\n"
-        "%" PARAM_ENTITY_NAME ";\n",
-        NULL,
-        NULL
-    };
-
-    XML_SetUserData(parser, &test_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader);
-    XML_SetEntityDeclHandler(parser, param_entity_match_handler);
-    entity_name_to_match = XCS(PARAM_ENTITY_NAME);
-    entity_value_to_match = XCS(PARAM_ENTITY_CORE_VALUE) XCS("\n");
-    entity_match_flag = ENTITY_MATCH_NOT_FOUND;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (entity_match_flag == ENTITY_MATCH_FAIL)
-        fail("Parameter entity CR->NEWLINE conversion failed");
-    else if (entity_match_flag == ENTITY_MATCH_NOT_FOUND)
-        fail("Parameter entity not parsed");
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc/>";
+  ExtTest test_data
+      = {"<!ENTITY % " PARAM_ENTITY_NAME " '" PARAM_ENTITY_CORE_VALUE "\r'>\n"
+         "%" PARAM_ENTITY_NAME ";\n",
+         NULL, NULL};
+
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader);
+  XML_SetEntityDeclHandler(g_parser, param_entity_match_handler);
+  entity_name_to_match = XCS(PARAM_ENTITY_NAME);
+  entity_value_to_match = XCS(PARAM_ENTITY_CORE_VALUE) XCS("\n");
+  entity_match_flag = ENTITY_MATCH_NOT_FOUND;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (entity_match_flag == ENTITY_MATCH_FAIL)
+    fail("Parameter entity CR->NEWLINE conversion failed");
+  else if (entity_match_flag == ENTITY_MATCH_NOT_FOUND)
+    fail("Parameter entity not parsed");
 }
 #undef PARAM_ENTITY_NAME
 #undef PARAM_ENTITY_CORE_VALUE
 END_TEST
 
-START_TEST(test_invalid_character_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY entity '&#x110000;'>\n"
-        "]>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_invalid_character_entity) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY entity '&#x110000;'>\n"
+                     "]>\n"
+                     "<doc>&entity;</doc>";
 
-    expect_failure(text, XML_ERROR_BAD_CHAR_REF,
-                   "Out of range character reference not faulted");
+  expect_failure(text, XML_ERROR_BAD_CHAR_REF,
+                 "Out of range character reference not faulted");
 }
 END_TEST
 
-START_TEST(test_invalid_character_entity_2)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY entity '&#xg0;'>\n"
-        "]>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_invalid_character_entity_2) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY entity '&#xg0;'>\n"
+                     "]>\n"
+                     "<doc>&entity;</doc>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Out of range character reference not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Out of range character reference not faulted");
 }
 END_TEST
 
-START_TEST(test_invalid_character_entity_3)
-{
-    const char text[] =
-        /* <!DOCTYPE doc [\n */
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
-        /* U+0E04 = KHO KHWAI
-         * U+0E08 = CHO CHAN */
-        /* <!ENTITY entity '&\u0e04\u0e08;'>\n */
-        "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0e\0n\0t\0i\0t\0y\0 "
-        "\0'\0&\x0e\x04\x0e\x08\0;\0'\0>\0\n"
-        /* ]>\n */
-        "\0]\0>\0\n"
-        /* <doc>&entity;</doc> */
-        "\0<\0d\0o\0c\0>\0&\0e\0n\0t\0i\0t\0y\0;\0<\0/\0d\0o\0c\0>";
+START_TEST(test_invalid_character_entity_3) {
+  const char text[] =
+      /* <!DOCTYPE doc [\n */
+      "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
+      /* U+0E04 = KHO KHWAI
+       * U+0E08 = CHO CHAN */
+      /* <!ENTITY entity '&\u0e04\u0e08;'>\n */
+      "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0e\0n\0t\0i\0t\0y\0 "
+      "\0'\0&\x0e\x04\x0e\x08\0;\0'\0>\0\n"
+      /* ]>\n */
+      "\0]\0>\0\n"
+      /* <doc>&entity;</doc> */
+      "\0<\0d\0o\0c\0>\0&\0e\0n\0t\0i\0t\0y\0;\0<\0/\0d\0o\0c\0>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Invalid start of entity name not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_UNDEFINED_ENTITY)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Invalid start of entity name not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_UNDEFINED_ENTITY)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_invalid_character_entity_4)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY entity '&#1114112;'>\n" /* = &#x110000 */
-        "]>\n"
-        "<doc>&entity;</doc>";
+START_TEST(test_invalid_character_entity_4) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY entity '&#1114112;'>\n" /* = &#x110000 */
+                     "]>\n"
+                     "<doc>&entity;</doc>";
 
-    expect_failure(text, XML_ERROR_BAD_CHAR_REF,
-                   "Out of range character reference not faulted");
+  expect_failure(text, XML_ERROR_BAD_CHAR_REF,
+                 "Out of range character reference not faulted");
 }
 END_TEST
 
-
 /* Test that processing instructions are picked up by a default handler */
-START_TEST(test_pi_handled_in_default)
-{
-    const char *text = "<?test processing instruction?>\n<doc/>";
-    const XML_Char *expected = XCS("<?test processing instruction?>\n<doc/>");
-    CharData storage;
+START_TEST(test_pi_handled_in_default) {
+  const char *text = "<?test processing instruction?>\n<doc/>";
+  const XML_Char *expected = XCS("<?test processing instruction?>\n<doc/>");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE)== XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-
 /* Test that comments are picked up by a default handler */
-START_TEST(test_comment_handled_in_default)
-{
-    const char *text = "<!-- This is a comment -->\n<doc/>";
-    const XML_Char *expected = XCS("<!-- This is a comment -->\n<doc/>");
-    CharData storage;
+START_TEST(test_comment_handled_in_default) {
+  const char *text = "<!-- This is a comment -->\n<doc/>";
+  const XML_Char *expected = XCS("<!-- This is a comment -->\n<doc/>");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetDefaultHandler(parser, accumulate_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetDefaultHandler(g_parser, accumulate_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test PIs that look almost but not quite like XML declarations */
 static void XMLCALL
-accumulate_pi_characters(void *userData,
-                         const XML_Char *target,
-                         const XML_Char *data)
-{
-    CharData *storage = (CharData *)userData;
-
-    CharData_AppendXMLChars(storage, target, -1);
-    CharData_AppendXMLChars(storage, XCS(": "), 2);
-    CharData_AppendXMLChars(storage, data, -1);
-    CharData_AppendXMLChars(storage, XCS("\n"), 1);
-}
-
-START_TEST(test_pi_yml)
-{
-    const char *text = "<?yml something like data?><doc/>";
-    const XML_Char *expected = XCS("yml: something like data\n");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetProcessingInstructionHandler(parser, accumulate_pi_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_pi_xnl)
-{
-    const char *text = "<?xnl nothing like data?><doc/>";
-    const XML_Char *expected = XCS("xnl: nothing like data\n");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetProcessingInstructionHandler(parser, accumulate_pi_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_pi_xmm)
-{
-    const char *text = "<?xmm everything like data?><doc/>";
-    const XML_Char *expected = XCS("xmm: everything like data\n");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetProcessingInstructionHandler(parser, accumulate_pi_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_utf16_pi)
-{
-    const char text[] =
-        /* <?{KHO KHWAI}{CHO CHAN}?>
-         * where {KHO KHWAI} = U+0E04
-         * and   {CHO CHAN}  = U+0E08
-         */
-        "<\0?\0\x04\x0e\x08\x0e?\0>\0"
-        /* <q/> */
-        "<\0q\0/\0>\0";
+accumulate_pi_characters(void *userData, const XML_Char *target,
+                         const XML_Char *data) {
+  CharData *storage = (CharData *)userData;
+
+  CharData_AppendXMLChars(storage, target, -1);
+  CharData_AppendXMLChars(storage, XCS(": "), 2);
+  CharData_AppendXMLChars(storage, data, -1);
+  CharData_AppendXMLChars(storage, XCS("\n"), 1);
+}
+
+START_TEST(test_pi_yml) {
+  const char *text = "<?yml something like data?><doc/>";
+  const XML_Char *expected = XCS("yml: something like data\n");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_pi_xnl) {
+  const char *text = "<?xnl nothing like data?><doc/>";
+  const XML_Char *expected = XCS("xnl: nothing like data\n");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_pi_xmm) {
+  const char *text = "<?xmm everything like data?><doc/>";
+  const XML_Char *expected = XCS("xmm: everything like data\n");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_utf16_pi) {
+  const char text[] =
+      /* <?{KHO KHWAI}{CHO CHAN}?>
+       * where {KHO KHWAI} = U+0E04
+       * and   {CHO CHAN}  = U+0E08
+       */
+      "<\0?\0\x04\x0e\x08\x0e?\0>\0"
+      /* <q/> */
+      "<\0q\0/\0>\0";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x0e04\x0e08: \n");
+  const XML_Char *expected = XCS("\x0e04\x0e08: \n");
 #else
-    const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
+  const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
 #endif
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetProcessingInstructionHandler(parser, accumulate_pi_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_utf16_be_pi)
-{
-    const char text[] =
-        /* <?{KHO KHWAI}{CHO CHAN}?>
-         * where {KHO KHWAI} = U+0E04
-         * and   {CHO CHAN}  = U+0E08
-         */
-        "\0<\0?\x0e\x04\x0e\x08\0?\0>"
-        /* <q/> */
-        "\0<\0q\0/\0>";
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_utf16_be_pi) {
+  const char text[] =
+      /* <?{KHO KHWAI}{CHO CHAN}?>
+       * where {KHO KHWAI} = U+0E04
+       * and   {CHO CHAN}  = U+0E08
+       */
+      "\0<\0?\x0e\x04\x0e\x08\0?\0>"
+      /* <q/> */
+      "\0<\0q\0/\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x0e04\x0e08: \n");
+  const XML_Char *expected = XCS("\x0e04\x0e08: \n");
 #else
-    const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
+  const XML_Char *expected = XCS("\xe0\xb8\x84\xe0\xb8\x88: \n");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetProcessingInstructionHandler(parser, accumulate_pi_characters);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetProcessingInstructionHandler(g_parser, accumulate_pi_characters);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test that comments can be picked up and translated */
 static void XMLCALL
-accumulate_comment(void *userData,
-                   const XML_Char *data)
-{
-    CharData *storage = (CharData *)userData;
+accumulate_comment(void *userData, const XML_Char *data) {
+  CharData *storage = (CharData *)userData;
 
-    CharData_AppendXMLChars(storage, data, -1);
+  CharData_AppendXMLChars(storage, data, -1);
 }
 
-START_TEST(test_utf16_be_comment)
-{
-    const char text[] =
-        /* <!-- Comment A --> */
-        "\0<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0A\0 \0-\0-\0>\0\n"
-        /* <doc/> */
-        "\0<\0d\0o\0c\0/\0>";
-    const XML_Char *expected = XCS(" Comment A ");
-    CharData storage;
+START_TEST(test_utf16_be_comment) {
+  const char text[] =
+      /* <!-- Comment A --> */
+      "\0<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0A\0 \0-\0-\0>\0\n"
+      /* <doc/> */
+      "\0<\0d\0o\0c\0/\0>";
+  const XML_Char *expected = XCS(" Comment A ");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetCommentHandler(parser, accumulate_comment);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetCommentHandler(g_parser, accumulate_comment);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_utf16_le_comment)
-{
-    const char text[] =
-        /* <!-- Comment B --> */
-        "<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0B\0 \0-\0-\0>\0\n\0"
-        /* <doc/> */
-        "<\0d\0o\0c\0/\0>\0";
-    const XML_Char *expected = XCS(" Comment B ");
-    CharData storage;
+START_TEST(test_utf16_le_comment) {
+  const char text[] =
+      /* <!-- Comment B --> */
+      "<\0!\0-\0-\0 \0C\0o\0m\0m\0e\0n\0t\0 \0B\0 \0-\0-\0>\0\n\0"
+      /* <doc/> */
+      "<\0d\0o\0c\0/\0>\0";
+  const XML_Char *expected = XCS(" Comment B ");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetCommentHandler(parser, accumulate_comment);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetCommentHandler(g_parser, accumulate_comment);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
@@ -5849,581 +5368,495 @@ END_TEST
  * conversion but no conversion function is faulted
  */
 static int XMLCALL
-failing_converter(void *UNUSED_P(data), const char *UNUSED_P(s))
-{
-    /* Always claim to have failed */
-    return -1;
+failing_converter(void *data, const char *s) {
+  UNUSED_P(data);
+  UNUSED_P(s);
+  /* Always claim to have failed */
+  return -1;
 }
 
 static int XMLCALL
-prefix_converter(void *UNUSED_P(data), const char *s)
-{
-    /* If the first byte is 0xff, raise an error */
-    if (s[0] == (char)-1)
-        return -1;
-    /* Just add the low bits of the first byte to the second */
-    return (s[1] + (s[0] & 0x7f)) & 0x01ff;
+prefix_converter(void *data, const char *s) {
+  UNUSED_P(data);
+  /* If the first byte is 0xff, raise an error */
+  if (s[0] == (char)-1)
+    return -1;
+  /* Just add the low bits of the first byte to the second */
+  return (s[1] + (s[0] & 0x7f)) & 0x01ff;
 }
 
 static int XMLCALL
-MiscEncodingHandler(void *data,
-                    const XML_Char *encoding,
-                    XML_Encoding *info)
-{
-    int i;
-    int high_map = -2; /* Assume a 2-byte sequence */
-
-    if (!xcstrcmp(encoding, XCS("invalid-9")) ||
-        !xcstrcmp(encoding, XCS("ascii-like")) ||
-        !xcstrcmp(encoding, XCS("invalid-len")) ||
-        !xcstrcmp(encoding, XCS("invalid-a")) ||
-        !xcstrcmp(encoding, XCS("invalid-surrogate")) ||
-        !xcstrcmp(encoding, XCS("invalid-high")))
-        high_map = -1;
-
-    for (i = 0; i < 128; ++i)
-        info->map[i] = i;
-    for (; i < 256; ++i)
-        info->map[i] = high_map;
-
-    /* If required, put an invalid value in the ASCII entries */
-    if (!xcstrcmp(encoding, XCS("invalid-9")))
-        info->map[9] = 5;
-    /* If required, have a top-bit set character starts a 5-byte sequence */
-    if (!xcstrcmp(encoding, XCS("invalid-len")))
-        info->map[0x81] = -5;
-    /* If required, make a top-bit set character a valid ASCII character */
-    if (!xcstrcmp(encoding, XCS("invalid-a")))
-        info->map[0x82] = 'a';
-    /* If required, give a top-bit set character a forbidden value,
-     * what would otherwise be the first of a surrogate pair.
-     */
-    if (!xcstrcmp(encoding, XCS("invalid-surrogate")))
-        info->map[0x83] = 0xd801;
-    /* If required, give a top-bit set character too high a value */
-    if (!xcstrcmp(encoding, XCS("invalid-high")))
-        info->map[0x84] = 0x010101;
-
-    info->data = data;
-    info->release = NULL;
-    if (!xcstrcmp(encoding, XCS("failing-conv")))
-        info->convert = failing_converter;
-    else if (!xcstrcmp(encoding, XCS("prefix-conv")))
-        info->convert = prefix_converter;
-    else
-        info->convert = NULL;
-    return XML_STATUS_OK;
+MiscEncodingHandler(void *data, const XML_Char *encoding, XML_Encoding *info) {
+  int i;
+  int high_map = -2; /* Assume a 2-byte sequence */
+
+  if (! xcstrcmp(encoding, XCS("invalid-9"))
+      || ! xcstrcmp(encoding, XCS("ascii-like"))
+      || ! xcstrcmp(encoding, XCS("invalid-len"))
+      || ! xcstrcmp(encoding, XCS("invalid-a"))
+      || ! xcstrcmp(encoding, XCS("invalid-surrogate"))
+      || ! xcstrcmp(encoding, XCS("invalid-high")))
+    high_map = -1;
+
+  for (i = 0; i < 128; ++i)
+    info->map[i] = i;
+  for (; i < 256; ++i)
+    info->map[i] = high_map;
+
+  /* If required, put an invalid value in the ASCII entries */
+  if (! xcstrcmp(encoding, XCS("invalid-9")))
+    info->map[9] = 5;
+  /* If required, have a top-bit set character starts a 5-byte sequence */
+  if (! xcstrcmp(encoding, XCS("invalid-len")))
+    info->map[0x81] = -5;
+  /* If required, make a top-bit set character a valid ASCII character */
+  if (! xcstrcmp(encoding, XCS("invalid-a")))
+    info->map[0x82] = 'a';
+  /* If required, give a top-bit set character a forbidden value,
+   * what would otherwise be the first of a surrogate pair.
+   */
+  if (! xcstrcmp(encoding, XCS("invalid-surrogate")))
+    info->map[0x83] = 0xd801;
+  /* If required, give a top-bit set character too high a value */
+  if (! xcstrcmp(encoding, XCS("invalid-high")))
+    info->map[0x84] = 0x010101;
+
+  info->data = data;
+  info->release = NULL;
+  if (! xcstrcmp(encoding, XCS("failing-conv")))
+    info->convert = failing_converter;
+  else if (! xcstrcmp(encoding, XCS("prefix-conv")))
+    info->convert = prefix_converter;
+  else
+    info->convert = NULL;
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_missing_encoding_conversion_fn)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='no-conv'?>\n"
-        "<doc>\x81</doc>";
+START_TEST(test_missing_encoding_conversion_fn) {
+  const char *text = "<?xml version='1.0' encoding='no-conv'?>\n"
+                     "<doc>\x81</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    /* MiscEncodingHandler sets up an encoding with every top-bit-set
-     * character introducing a two-byte sequence.  For this, it
-     * requires a convert function.  The above function call doesn't
-     * pass one through, so when BadEncodingHandler actually gets
-     * called it should supply an invalid encoding.
-     */
-    expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
-                   "Encoding with missing convert() not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  /* MiscEncodingHandler sets up an encoding with every top-bit-set
+   * character introducing a two-byte sequence.  For this, it
+   * requires a convert function.  The above function call doesn't
+   * pass one through, so when BadEncodingHandler actually gets
+   * called it should supply an invalid encoding.
+   */
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Encoding with missing convert() not faulted");
 }
 END_TEST
 
-START_TEST(test_failing_encoding_conversion_fn)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='failing-conv'?>\n"
-        "<doc>\x81</doc>";
+START_TEST(test_failing_encoding_conversion_fn) {
+  const char *text = "<?xml version='1.0' encoding='failing-conv'?>\n"
+                     "<doc>\x81</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    /* BadEncodingHandler sets up an encoding with every top-bit-set
-     * character introducing a two-byte sequence.  For this, it
-     * requires a convert function.  The above function call passes
-     * one that insists all possible sequences are invalid anyway.
-     */
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Encoding with failing convert() not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  /* BadEncodingHandler sets up an encoding with every top-bit-set
+   * character introducing a two-byte sequence.  For this, it
+   * requires a convert function.  The above function call passes
+   * one that insists all possible sequences are invalid anyway.
+   */
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Encoding with failing convert() not faulted");
 }
 END_TEST
 
 /* Test unknown encoding conversions */
-START_TEST(test_unknown_encoding_success)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        /* Equivalent to <eoc>Hello, world</eoc> */
-        "<\x81\x64\x80oc>Hello, world</\x81\x64\x80oc>";
+START_TEST(test_unknown_encoding_success) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     /* Equivalent to <eoc>Hello, world</eoc> */
+                     "<\x81\x64\x80oc>Hello, world</\x81\x64\x80oc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    run_character_check(text, XCS("Hello, world"));
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  run_character_check(text, XCS("Hello, world"));
 }
 END_TEST
 
 /* Test bad name character in unknown encoding */
-START_TEST(test_unknown_encoding_bad_name)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<\xff\x64oc>Hello, world</\xff\x64oc>";
+START_TEST(test_unknown_encoding_bad_name) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<\xff\x64oc>Hello, world</\xff\x64oc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Bad name start in unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Bad name start in unknown encoding not faulted");
 }
 END_TEST
 
 /* Test bad mid-name character in unknown encoding */
-START_TEST(test_unknown_encoding_bad_name_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<d\xffoc>Hello, world</d\xffoc>";
+START_TEST(test_unknown_encoding_bad_name_2) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<d\xffoc>Hello, world</d\xffoc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Bad name in unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Bad name in unknown encoding not faulted");
 }
 END_TEST
 
 /* Test element name that is long enough to fill the conversion buffer
  * in an unknown encoding, finishing with an encoded character.
  */
-START_TEST(test_unknown_encoding_long_name_1)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>"
-        "Hi"
-        "</abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>";
-    const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
-    CharData storage;
+START_TEST(test_unknown_encoding_long_name_1) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>"
+                     "Hi"
+                     "</abcdefghabcdefghabcdefghijkl\x80m\x80n\x80o\x80p>";
+  const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    XML_SetStartElementHandler(parser, record_element_start_handler);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  XML_SetStartElementHandler(g_parser, record_element_start_handler);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test element name that is long enough to fill the conversion buffer
  * in an unknown encoding, finishing with an simple character.
  */
-START_TEST(test_unknown_encoding_long_name_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<abcdefghabcdefghabcdefghijklmnop>"
-        "Hi"
-        "</abcdefghabcdefghabcdefghijklmnop>";
-    const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
-    CharData storage;
+START_TEST(test_unknown_encoding_long_name_2) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<abcdefghabcdefghabcdefghijklmnop>"
+                     "Hi"
+                     "</abcdefghabcdefghabcdefghijklmnop>";
+  const XML_Char *expected = XCS("abcdefghabcdefghabcdefghijklmnop");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    XML_SetStartElementHandler(parser, record_element_start_handler);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  XML_SetStartElementHandler(g_parser, record_element_start_handler);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_invalid_unknown_encoding)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='invalid-9'?>\n"
-        "<doc>Hello world</doc>";
+START_TEST(test_invalid_unknown_encoding) {
+  const char *text = "<?xml version='1.0' encoding='invalid-9'?>\n"
+                     "<doc>Hello world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
-                   "Invalid unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Invalid unknown encoding not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_ascii_encoding_ok)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='ascii-like'?>\n"
-        "<doc>Hello, world</doc>";
+START_TEST(test_unknown_ascii_encoding_ok) {
+  const char *text = "<?xml version='1.0' encoding='ascii-like'?>\n"
+                     "<doc>Hello, world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    run_character_check(text, XCS("Hello, world"));
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  run_character_check(text, XCS("Hello, world"));
 }
 END_TEST
 
-START_TEST(test_unknown_ascii_encoding_fail)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='ascii-like'?>\n"
-        "<doc>Hello, \x80 world</doc>";
+START_TEST(test_unknown_ascii_encoding_fail) {
+  const char *text = "<?xml version='1.0' encoding='ascii-like'?>\n"
+                     "<doc>Hello, \x80 world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid character not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid character not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_invalid_length)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='invalid-len'?>\n"
-        "<doc>Hello, world</doc>";
+START_TEST(test_unknown_encoding_invalid_length) {
+  const char *text = "<?xml version='1.0' encoding='invalid-len'?>\n"
+                     "<doc>Hello, world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
-                   "Invalid unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Invalid unknown encoding not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_invalid_topbit)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='invalid-a'?>\n"
-        "<doc>Hello, world</doc>";
+START_TEST(test_unknown_encoding_invalid_topbit) {
+  const char *text = "<?xml version='1.0' encoding='invalid-a'?>\n"
+                     "<doc>Hello, world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
-                   "Invalid unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Invalid unknown encoding not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_invalid_surrogate)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='invalid-surrogate'?>\n"
-        "<doc>Hello, \x82 world</doc>";
+START_TEST(test_unknown_encoding_invalid_surrogate) {
+  const char *text = "<?xml version='1.0' encoding='invalid-surrogate'?>\n"
+                     "<doc>Hello, \x82 world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid unknown encoding not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_invalid_high)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='invalid-high'?>\n"
-        "<doc>Hello, world</doc>";
+START_TEST(test_unknown_encoding_invalid_high) {
+  const char *text = "<?xml version='1.0' encoding='invalid-high'?>\n"
+                     "<doc>Hello, world</doc>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
-                   "Invalid unknown encoding not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_UNKNOWN_ENCODING,
+                 "Invalid unknown encoding not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_invalid_attr_value)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<doc attr='\xff\x30'/>";
+START_TEST(test_unknown_encoding_invalid_attr_value) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<doc attr='\xff\x30'/>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid attribute valid not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid attribute valid not faulted");
 }
 END_TEST
 
 /* Test an external entity parser set to use latin-1 detects UTF-16
  * BOMs correctly.
  */
-enum ee_parse_flags {
-    EE_PARSE_NONE = 0x00,
-    EE_PARSE_FULL_BUFFER = 0x01
-};
+enum ee_parse_flags { EE_PARSE_NONE = 0x00, EE_PARSE_FULL_BUFFER = 0x01 };
 
 typedef struct ExtTest2 {
-    const char *parse_text;
-    int parse_len;
-    const XML_Char *encoding;
-    CharData *storage;
-    enum ee_parse_flags flags;
+  const char *parse_text;
+  int parse_len;
+  const XML_Char *encoding;
+  CharData *storage;
+  enum ee_parse_flags flags;
 } ExtTest2;
 
 static int XMLCALL
-external_entity_loader2(XML_Parser parser,
-                        const XML_Char *context,
-                        const XML_Char *UNUSED_P(base),
-                        const XML_Char *UNUSED_P(systemId),
-                        const XML_Char *UNUSED_P(publicId))
-{
-    ExtTest2 *test_data = (ExtTest2 *)XML_GetUserData(parser);
-    XML_Parser extparser;
-
-    extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (extparser == NULL)
-        fail("Coulr not create external entity parser");
-    if (test_data->encoding != NULL) {
-        if (!XML_SetEncoding(extparser, test_data->encoding))
-            fail("XML_SetEncoding() ignored for external entity");
-    }
-    if (test_data->flags & EE_PARSE_FULL_BUFFER) {
-        if (XML_Parse(extparser,
-                      test_data->parse_text,
-                      test_data->parse_len,
-                      XML_TRUE) == XML_STATUS_ERROR) {
-            xml_failure(extparser);
-        }
-    }
-    else if (_XML_Parse_SINGLE_BYTES(extparser,
-                                     test_data->parse_text,
-                                     test_data->parse_len,
-                                     XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(extparser);
-    }
-
-    XML_ParserFree(extparser);
-    return XML_STATUS_OK;
+external_entity_loader2(XML_Parser parser, const XML_Char *context,
+                        const XML_Char *base, const XML_Char *systemId,
+                        const XML_Char *publicId) {
+  ExtTest2 *test_data = (ExtTest2 *)XML_GetUserData(parser);
+  XML_Parser extparser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (extparser == NULL)
+    fail("Coulr not create external entity parser");
+  if (test_data->encoding != NULL) {
+    if (! XML_SetEncoding(extparser, test_data->encoding))
+      fail("XML_SetEncoding() ignored for external entity");
+  }
+  if (test_data->flags & EE_PARSE_FULL_BUFFER) {
+    if (XML_Parse(extparser, test_data->parse_text, test_data->parse_len,
+                  XML_TRUE)
+        == XML_STATUS_ERROR) {
+      xml_failure(extparser);
+    }
+  } else if (_XML_Parse_SINGLE_BYTES(extparser, test_data->parse_text,
+                                     test_data->parse_len, XML_TRUE)
+             == XML_STATUS_ERROR) {
+    xml_failure(extparser);
+  }
+
+  XML_ParserFree(extparser);
+  return XML_STATUS_OK;
 }
 
 /* Test that UTF-16 BOM does not select UTF-16 given explicit encoding */
 static void XMLCALL
-ext2_accumulate_characters(void *userData, const XML_Char *s, int len)
-{
-    ExtTest2 *test_data = (ExtTest2 *)userData;
-    accumulate_characters(test_data->storage, s, len);
-}
-
-START_TEST(test_ext_entity_latin1_utf16le_bom)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        /* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
-        /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
-         *   0x4c = L and 0x20 is a space
-         */
-        "\xff\xfe\x4c\x20",
-        4,
-        XCS("iso-8859-1"),
-        NULL,
-        EE_PARSE_NONE
-    };
+ext2_accumulate_characters(void *userData, const XML_Char *s, int len) {
+  ExtTest2 *test_data = (ExtTest2 *)userData;
+  accumulate_characters(test_data->storage, s, len);
+}
+
+START_TEST(test_ext_entity_latin1_utf16le_bom) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
+         /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
+          *   0x4c = L and 0x20 is a space
+          */
+         "\xff\xfe\x4c\x20", 4, XCS("iso-8859-1"), NULL, EE_PARSE_NONE};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00ff\x00feL ");
+  const XML_Char *expected = XCS("\x00ff\x00feL ");
 #else
-    /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
-    const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
+  /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
+  const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
 #endif
-    CharData storage;
-
-
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_ext_entity_latin1_utf16be_bom)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        /* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
-        /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
-         *   0x4c = L and 0x20 is a space
-         */
-        "\xfe\xff\x20\x4c",
-        4,
-        XCS("iso-8859-1"),
-        NULL,
-        EE_PARSE_NONE
-    };
+  CharData storage;
+
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_ext_entity_latin1_utf16be_bom) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
+         /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
+          *   0x4c = L and 0x20 is a space
+          */
+         "\xfe\xff\x20\x4c", 4, XCS("iso-8859-1"), NULL, EE_PARSE_NONE};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00fe\x00ff L");
+  const XML_Char *expected = XCS("\x00fe\x00ff L");
 #else
-    /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
-    const XML_Char *expected = XCS("\xc3\xbe\xc3\xbf L");
+  /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
+  const XML_Char *expected = XCS("\xc3\xbe\xc3\xbf L");
 #endif
-    CharData storage;
-
+  CharData storage;
 
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-
 /* Parsing the full buffer rather than a byte at a time makes a
  * difference to the encoding scanning code, so repeat the above tests
  * without breaking them down by byte.
  */
-START_TEST(test_ext_entity_latin1_utf16le_bom2)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        /* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
-        /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
-         *   0x4c = L and 0x20 is a space
-         */
-        "\xff\xfe\x4c\x20",
-        4,
-        XCS("iso-8859-1"),
-        NULL,
-        EE_PARSE_FULL_BUFFER
-    };
+START_TEST(test_ext_entity_latin1_utf16le_bom2) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
+         /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
+          *   0x4c = L and 0x20 is a space
+          */
+         "\xff\xfe\x4c\x20", 4, XCS("iso-8859-1"), NULL, EE_PARSE_FULL_BUFFER};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00ff\x00feL ");
+  const XML_Char *expected = XCS("\x00ff\x00feL ");
 #else
-    /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
-    const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
+  /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
+  const XML_Char *expected = XCS("\xc3\xbf\xc3\xbeL ");
 #endif
-    CharData storage;
-
-
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_ext_entity_latin1_utf16be_bom2)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        /* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
-        /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
-         *   0x4c = L and 0x20 is a space
-         */
-        "\xfe\xff\x20\x4c",
-        4,
-        XCS("iso-8859-1"),
-        NULL,
-        EE_PARSE_FULL_BUFFER
-    };
+  CharData storage;
+
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_ext_entity_latin1_utf16be_bom2) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {/* If UTF-16, 0xfeff is the BOM and 0x204c is black left bullet */
+         /* If Latin-1, 0xff = Y-diaeresis, 0xfe = lowercase thorn,
+          *   0x4c = L and 0x20 is a space
+          */
+         "\xfe\xff\x20\x4c", 4, XCS("iso-8859-1"), NULL, EE_PARSE_FULL_BUFFER};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00fe\x00ff L");
+  const XML_Char *expected = XCS("\x00fe\x00ff L");
 #else
-    /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
-    const XML_Char *expected = "\xc3\xbe\xc3\xbf L";
+  /* In UTF-8, y-diaeresis is 0xc3 0xbf, lowercase thorn is 0xc3 0xbe */
+  const XML_Char *expected = "\xc3\xbe\xc3\xbf L";
 #endif
-    CharData storage;
+  CharData storage;
 
-
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (XML_Parse(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test little-endian UTF-16 given an explicit big-endian encoding */
-START_TEST(test_ext_entity_utf16_be)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        "<\0e\0/\0>\0",
-        8,
-        XCS("utf-16be"),
-        NULL,
-        EE_PARSE_NONE
-    };
+START_TEST(test_ext_entity_utf16_be) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {"<\0e\0/\0>\0", 8, XCS("utf-16be"), NULL, EE_PARSE_NONE};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
+  const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
 #else
-    const XML_Char *expected =
-        XCS("\xe3\xb0\x80"   /* U+3C00 */
-            "\xe6\x94\x80"   /* U+6500 */
-            "\xe2\xbc\x80"   /* U+2F00 */
-            "\xe3\xb8\x80"); /* U+3E00 */
+  const XML_Char *expected = XCS("\xe3\xb0\x80"   /* U+3C00 */
+                                 "\xe6\x94\x80"   /* U+6500 */
+                                 "\xe2\xbc\x80"   /* U+2F00 */
+                                 "\xe3\xb8\x80"); /* U+3E00 */
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test big-endian UTF-16 given an explicit little-endian encoding */
-START_TEST(test_ext_entity_utf16_le)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        "\0<\0e\0/\0>",
-        8,
-        XCS("utf-16le"),
-        NULL,
-        EE_PARSE_NONE
-    };
+START_TEST(test_ext_entity_utf16_le) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {"\0<\0e\0/\0>", 8, XCS("utf-16le"), NULL, EE_PARSE_NONE};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
+  const XML_Char *expected = XCS("\x3c00\x6500\x2f00\x3e00");
 #else
-    const XML_Char *expected =
-        XCS("\xe3\xb0\x80"   /* U+3C00 */
-            "\xe6\x94\x80"   /* U+6500 */
-            "\xe2\xbc\x80"   /* U+2F00 */
-            "\xe3\xb8\x80"); /* U+3E00 */
+  const XML_Char *expected = XCS("\xe3\xb0\x80"   /* U+3C00 */
+                                 "\xe6\x94\x80"   /* U+6500 */
+                                 "\xe2\xbc\x80"   /* U+2F00 */
+                                 "\xe3\xb8\x80"); /* U+3E00 */
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
@@ -6435,275 +5868,246 @@ END_TEST
  * exercise different code paths in the initial scanning routines.
  */
 typedef struct ExtFaults2 {
-    const char *parse_text;
-    int parse_len;
-    const char *fail_text;
-    const XML_Char *encoding;
-    enum XML_Error error;
+  const char *parse_text;
+  int parse_len;
+  const char *fail_text;
+  const XML_Char *encoding;
+  enum XML_Error error;
 } ExtFaults2;
 
 static int XMLCALL
-external_entity_faulter2(XML_Parser parser,
-                         const XML_Char *context,
-                         const XML_Char *UNUSED_P(base),
-                         const XML_Char *UNUSED_P(systemId),
-                         const XML_Char *UNUSED_P(publicId))
-{
-    ExtFaults2 *test_data = (ExtFaults2 *)XML_GetUserData(parser);
-    XML_Parser extparser;
-
-    extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (extparser == NULL)
-        fail("Could not create external entity parser");
-    if (test_data->encoding != NULL) {
-        if (!XML_SetEncoding(extparser, test_data->encoding))
-            fail("XML_SetEncoding() ignored for external entity");
-    }
-    if (XML_Parse(extparser,
-                  test_data->parse_text,
-                  test_data->parse_len,
-                  XML_TRUE) != XML_STATUS_ERROR)
-        fail(test_data->fail_text);
-    if (XML_GetErrorCode(extparser) != test_data->error)
-        xml_failure(extparser);
-
-    XML_ParserFree(extparser);
-    return XML_STATUS_ERROR;
-}
-
-START_TEST(test_ext_entity_utf16_unknown)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtFaults2 test_data = {
-        "a\0b\0c\0",
-        6,
-        "Invalid character in entity not faulted",
-        NULL,
-        XML_ERROR_INVALID_TOKEN
-    };
-
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter2);
-    XML_SetUserData(parser, &test_data);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Invalid character should not have been accepted");
+external_entity_faulter2(XML_Parser parser, const XML_Char *context,
+                         const XML_Char *base, const XML_Char *systemId,
+                         const XML_Char *publicId) {
+  ExtFaults2 *test_data = (ExtFaults2 *)XML_GetUserData(parser);
+  XML_Parser extparser;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  extparser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (extparser == NULL)
+    fail("Could not create external entity parser");
+  if (test_data->encoding != NULL) {
+    if (! XML_SetEncoding(extparser, test_data->encoding))
+      fail("XML_SetEncoding() ignored for external entity");
+  }
+  if (XML_Parse(extparser, test_data->parse_text, test_data->parse_len,
+                XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail(test_data->fail_text);
+  if (XML_GetErrorCode(extparser) != test_data->error)
+    xml_failure(extparser);
+
+  XML_ParserFree(extparser);
+  return XML_STATUS_ERROR;
+}
+
+START_TEST(test_ext_entity_utf16_unknown) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtFaults2 test_data
+      = {"a\0b\0c\0", 6, "Invalid character in entity not faulted", NULL,
+         XML_ERROR_INVALID_TOKEN};
+
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter2);
+  XML_SetUserData(g_parser, &test_data);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Invalid character should not have been accepted");
 }
 END_TEST
 
 /* Test not-quite-UTF-8 BOM (0xEF 0xBB 0xBF) */
-START_TEST(test_ext_entity_utf8_non_bom)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    ExtTest2 test_data = {
-        "\xef\xbb\x80", /* Arabic letter DAD medial form, U+FEC0 */
-        3,
-        NULL,
-        NULL,
-        EE_PARSE_NONE
-    };
+START_TEST(test_ext_entity_utf8_non_bom) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  ExtTest2 test_data
+      = {"\xef\xbb\x80", /* Arabic letter DAD medial form, U+FEC0 */
+         3, NULL, NULL, EE_PARSE_NONE};
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\xfec0");
+  const XML_Char *expected = XCS("\xfec0");
 #else
-    const XML_Char *expected = XCS("\xef\xbb\x80");
+  const XML_Char *expected = XCS("\xef\xbb\x80");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test that UTF-8 in a CDATA section is correctly passed through */
-START_TEST(test_utf8_in_cdata_section)
-{
-    const char *text = "<doc><![CDATA[one \xc3\xa9 two]]></doc>";
+START_TEST(test_utf8_in_cdata_section) {
+  const char *text = "<doc><![CDATA[one \xc3\xa9 two]]></doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("one \x00e9 two");
+  const XML_Char *expected = XCS("one \x00e9 two");
 #else
-    const XML_Char *expected = XCS("one \xc3\xa9 two");
+  const XML_Char *expected = XCS("one \xc3\xa9 two");
 #endif
 
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
 /* Test that little-endian UTF-16 in a CDATA section is handled */
-START_TEST(test_utf8_in_cdata_section_2)
-{
-    const char *text = "<doc><![CDATA[\xc3\xa9]\xc3\xa9two]]></doc>";
+START_TEST(test_utf8_in_cdata_section_2) {
+  const char *text = "<doc><![CDATA[\xc3\xa9]\xc3\xa9two]]></doc>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e9]\x00e9two");
+  const XML_Char *expected = XCS("\x00e9]\x00e9two");
 #else
-    const XML_Char *expected = XCS("\xc3\xa9]\xc3\xa9two");
+  const XML_Char *expected = XCS("\xc3\xa9]\xc3\xa9two");
 #endif
 
-    run_character_check(text, expected);
+  run_character_check(text, expected);
 }
 END_TEST
 
 /* Test trailing spaces in elements are accepted */
 static void XMLCALL
-record_element_end_handler(void *userData,
-                           const XML_Char *name)
-{
-    CharData *storage = (CharData *)userData;
+record_element_end_handler(void *userData, const XML_Char *name) {
+  CharData *storage = (CharData *)userData;
 
-    CharData_AppendXMLChars(storage, XCS("/"), 1);
-    CharData_AppendXMLChars(storage, name, -1);
+  CharData_AppendXMLChars(storage, XCS("/"), 1);
+  CharData_AppendXMLChars(storage, name, -1);
 }
 
-START_TEST(test_trailing_spaces_in_elements)
-{
-    const char *text = "<doc   >Hi</doc >";
-    const XML_Char *expected = XCS("doc/doc");
-    CharData storage;
+START_TEST(test_trailing_spaces_in_elements) {
+  const char *text = "<doc   >Hi</doc >";
+  const XML_Char *expected = XCS("doc/doc");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetElementHandler(parser, record_element_start_handler,
-                          record_element_end_handler);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_utf16_attribute)
-{
-    const char text[] =
-        /* <d {KHO KHWAI}{CHO CHAN}='a'/>
-         * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-         * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
-         */
-        "<\0d\0 \0\x04\x0e\x08\x0e=\0'\0a\0'\0/\0>\0";
-    const XML_Char *expected = XCS("a");
-    CharData storage;
+  CharData_Init(&storage);
+  XML_SetElementHandler(g_parser, record_element_start_handler,
+                        record_element_end_handler);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
 
-    CharData_Init(&storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+START_TEST(test_utf16_attribute) {
+  const char text[] =
+      /* <d {KHO KHWAI}{CHO CHAN}='a'/>
+       * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+       * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
+       */
+      "<\0d\0 \0\x04\x0e\x08\x0e=\0'\0a\0'\0/\0>\0";
+  const XML_Char *expected = XCS("a");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_utf16_second_attr)
-{
-    /* <d a='1' {KHO KHWAI}{CHO CHAN}='2'/>
-         * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-         * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
-         */
-    const char text[] =
-        "<\0d\0 \0a\0=\0'\0\x31\0'\0 \0"
-        "\x04\x0e\x08\x0e=\0'\0\x32\0'\0/\0>\0";
-    const XML_Char *expected = XCS("1");
-    CharData storage;
+START_TEST(test_utf16_second_attr) {
+  /* <d a='1' {KHO KHWAI}{CHO CHAN}='2'/>
+   * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+   * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
+   */
+  const char text[] = "<\0d\0 \0a\0=\0'\0\x31\0'\0 \0"
+                      "\x04\x0e\x08\x0e=\0'\0\x32\0'\0/\0>\0";
+  const XML_Char *expected = XCS("1");
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_attr_after_solidus)
-{
-    const char *text = "<doc attr1='a' / attr2='b'>";
+START_TEST(test_attr_after_solidus) {
+  const char *text = "<doc attr1='a' / attr2='b'>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Misplaced / not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN, "Misplaced / not faulted");
 }
 END_TEST
 
 static void XMLCALL
-accumulate_entity_decl(void *userData,
-                       const XML_Char *entityName,
-                       int UNUSED_P(is_parameter_entity),
-                       const XML_Char *value,
-                       int value_length,
-                       const XML_Char *UNUSED_P(base),
-                       const XML_Char *UNUSED_P(systemId),
-                       const XML_Char *UNUSED_P(publicId),
-                       const XML_Char *UNUSED_P(notationName))
-{
-    CharData *storage = (CharData *)userData;
-
-    CharData_AppendXMLChars(storage, entityName, -1);
-    CharData_AppendXMLChars(storage, XCS("="), 1);
-    CharData_AppendXMLChars(storage, value, value_length);
-    CharData_AppendXMLChars(storage, XCS("\n"), 1);
-}
-
-
-START_TEST(test_utf16_pe)
-{
-    /* <!DOCTYPE doc [
-     * <!ENTITY % {KHO KHWAI}{CHO CHAN} '<!ELEMENT doc (#PCDATA)>'>
-     * %{KHO KHWAI}{CHO CHAN};
-     * ]>
-     * <doc></doc>
-     *
-     * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-     * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
-     */
-    const char text[] =
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
-        "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \x0e\x04\x0e\x08\0 "
-        "\0'\0<\0!\0E\0L\0E\0M\0E\0N\0T\0 "
-        "\0d\0o\0c\0 \0(\0#\0P\0C\0D\0A\0T\0A\0)\0>\0'\0>\0\n"
-        "\0%\x0e\x04\x0e\x08\0;\0\n"
-        "\0]\0>\0\n"
-        "\0<\0d\0o\0c\0>\0<\0/\0d\0o\0c\0>";
+accumulate_entity_decl(void *userData, const XML_Char *entityName,
+                       int is_parameter_entity, const XML_Char *value,
+                       int value_length, const XML_Char *base,
+                       const XML_Char *systemId, const XML_Char *publicId,
+                       const XML_Char *notationName) {
+  CharData *storage = (CharData *)userData;
+
+  UNUSED_P(is_parameter_entity);
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  UNUSED_P(notationName);
+  CharData_AppendXMLChars(storage, entityName, -1);
+  CharData_AppendXMLChars(storage, XCS("="), 1);
+  CharData_AppendXMLChars(storage, value, value_length);
+  CharData_AppendXMLChars(storage, XCS("\n"), 1);
+}
+
+START_TEST(test_utf16_pe) {
+  /* <!DOCTYPE doc [
+   * <!ENTITY % {KHO KHWAI}{CHO CHAN} '<!ELEMENT doc (#PCDATA)>'>
+   * %{KHO KHWAI}{CHO CHAN};
+   * ]>
+   * <doc></doc>
+   *
+   * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+   * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
+   */
+  const char text[] = "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0\n"
+                      "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \x0e\x04\x0e\x08\0 "
+                      "\0'\0<\0!\0E\0L\0E\0M\0E\0N\0T\0 "
+                      "\0d\0o\0c\0 \0(\0#\0P\0C\0D\0A\0T\0A\0)\0>\0'\0>\0\n"
+                      "\0%\x0e\x04\x0e\x08\0;\0\n"
+                      "\0]\0>\0\n"
+                      "\0<\0d\0o\0c\0>\0<\0/\0d\0o\0c\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected =
-        XCS("\x0e04\x0e08=<!ELEMENT doc (#PCDATA)>\n");
+  const XML_Char *expected = XCS("\x0e04\x0e08=<!ELEMENT doc (#PCDATA)>\n");
 #else
-    const XML_Char *expected =
-        XCS("\xe0\xb8\x84\xe0\xb8\x88=<!ELEMENT doc (#PCDATA)>\n");
+  const XML_Char *expected
+      = XCS("\xe0\xb8\x84\xe0\xb8\x88=<!ELEMENT doc (#PCDATA)>\n");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetEntityDeclHandler(parser, accumulate_entity_decl);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetEntityDeclHandler(g_parser, accumulate_entity_decl);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test that duff attribute description keywords are rejected */
-START_TEST(test_bad_attr_desc_keyword)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ATTLIST doc attr CDATA #!IMPLIED>\n"
-        "]>\n"
-        "<doc />";
+START_TEST(test_bad_attr_desc_keyword) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ATTLIST doc attr CDATA #!IMPLIED>\n"
+                     "]>\n"
+                     "<doc />";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Bad keyword !IMPLIED not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Bad keyword !IMPLIED not faulted");
 }
 END_TEST
 
@@ -6711,403 +6115,343 @@ END_TEST
  * UTF-16 characters with their top bytes non-zero are correctly
  * faulted
  */
-START_TEST(test_bad_attr_desc_keyword_utf16)
-{
-    /* <!DOCTYPE d [
-     * <!ATTLIST d a CDATA #{KHO KHWAI}{CHO CHAN}>
-     * ]><d/>
-     *
-     * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-     * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
-     */
-    const char text[] =
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
+START_TEST(test_bad_attr_desc_keyword_utf16) {
+  /* <!DOCTYPE d [
+   * <!ATTLIST d a CDATA #{KHO KHWAI}{CHO CHAN}>
+   * ]><d/>
+   *
+   * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+   * and   {CHO CHAN}  = U+0E08 = 0xe0 0xb8 0x88 in UTF-8
+   */
+  const char text[]
+      = "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
         "\0<\0!\0A\0T\0T\0L\0I\0S\0T\0 \0d\0 \0a\0 \0C\0D\0A\0T\0A\0 "
         "\0#\x0e\x04\x0e\x08\0>\0\n"
         "\0]\0>\0<\0d\0/\0>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Invalid UTF16 attribute keyword not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_SYNTAX)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Invalid UTF16 attribute keyword not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_SYNTAX)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that invalid syntax in a <!DOCTYPE> is rejected.  Do this
  * using prefix-encoding (see above) to trigger specific code paths
  */
-START_TEST(test_bad_doctype)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<!DOCTYPE doc [ \x80\x44 ]><doc/>";
+START_TEST(test_bad_doctype) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<!DOCTYPE doc [ \x80\x44 ]><doc/>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "Invalid bytes in DOCTYPE not faulted");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "Invalid bytes in DOCTYPE not faulted");
 }
 END_TEST
 
-START_TEST(test_bad_doctype_utf16)
-{
-    const char text[] =
-        /* <!DOCTYPE doc [ \x06f2 ]><doc/>
-         *
-         * U+06F2 = EXTENDED ARABIC-INDIC DIGIT TWO, a valid number
-         * (name character) but not a valid letter (name start character)
-         */
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0 "
-        "\x06\xf2"
-        "\0 \0]\0>\0<\0d\0o\0c\0/\0>";
+START_TEST(test_bad_doctype_utf16) {
+  const char text[] =
+      /* <!DOCTYPE doc [ \x06f2 ]><doc/>
+       *
+       * U+06F2 = EXTENDED ARABIC-INDIC DIGIT TWO, a valid number
+       * (name character) but not a valid letter (name start character)
+       */
+      "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0o\0c\0 \0[\0 "
+      "\x06\xf2"
+      "\0 \0]\0>\0<\0d\0o\0c\0/\0>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Invalid bytes in DOCTYPE not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_SYNTAX)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Invalid bytes in DOCTYPE not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_SYNTAX)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_bad_doctype_plus)
-{
-    const char *text =
-        "<!DOCTYPE 1+ [ <!ENTITY foo 'bar'> ]>\n"
-        "<1+>&foo;</1+>";
+START_TEST(test_bad_doctype_plus) {
+  const char *text = "<!DOCTYPE 1+ [ <!ENTITY foo 'bar'> ]>\n"
+                     "<1+>&foo;</1+>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "'+' in document name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "'+' in document name not faulted");
 }
 END_TEST
 
-START_TEST(test_bad_doctype_star)
-{
-    const char *text =
-        "<!DOCTYPE 1* [ <!ENTITY foo 'bar'> ]>\n"
-        "<1*>&foo;</1*>";
+START_TEST(test_bad_doctype_star) {
+  const char *text = "<!DOCTYPE 1* [ <!ENTITY foo 'bar'> ]>\n"
+                     "<1*>&foo;</1*>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "'*' in document name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "'*' in document name not faulted");
 }
 END_TEST
 
-START_TEST(test_bad_doctype_query)
-{
-    const char *text =
-        "<!DOCTYPE 1? [ <!ENTITY foo 'bar'> ]>\n"
-        "<1?>&foo;</1?>";
+START_TEST(test_bad_doctype_query) {
+  const char *text = "<!DOCTYPE 1? [ <!ENTITY foo 'bar'> ]>\n"
+                     "<1?>&foo;</1?>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "'?' in document name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "'?' in document name not faulted");
 }
 END_TEST
 
-START_TEST(test_unknown_encoding_bad_ignore)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>"
-        "<!DOCTYPE doc SYSTEM 'foo'>"
-        "<doc><e>&entity;</e></doc>";
-    ExtFaults fault = {
-        "<![IGNORE[<!ELEMENT \xffG (#PCDATA)*>]]>",
-        "Invalid character not faulted",
-        XCS("prefix-conv"),
-        XML_ERROR_INVALID_TOKEN
-    };
+START_TEST(test_unknown_encoding_bad_ignore) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>"
+                     "<!DOCTYPE doc SYSTEM 'foo'>"
+                     "<doc><e>&entity;</e></doc>";
+  ExtFaults fault = {"<![IGNORE[<!ELEMENT \xffG (#PCDATA)*>]]>",
+                     "Invalid character not faulted", XCS("prefix-conv"),
+                     XML_ERROR_INVALID_TOKEN};
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    XML_SetUserData(parser, &fault);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Bad IGNORE section with unknown encoding not failed");
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  XML_SetUserData(g_parser, &fault);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Bad IGNORE section with unknown encoding not failed");
 }
 END_TEST
 
-START_TEST(test_entity_in_utf16_be_attr)
-{
-    const char text[] =
-        /* <e a='&#228; &#x00E4;'></e> */
-        "\0<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 "
-        "\0&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>";
+START_TEST(test_entity_in_utf16_be_attr) {
+  const char text[] =
+      /* <e a='&#228; &#x00E4;'></e> */
+      "\0<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 "
+      "\0&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e4 \x00e4");
+  const XML_Char *expected = XCS("\x00e4 \x00e4");
 #else
-    const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
+  const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_entity_in_utf16_le_attr)
-{
-    const char text[] =
-        /* <e a='&#228; &#x00E4;'></e> */
-        "<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 \0"
-        "&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>\0";
+START_TEST(test_entity_in_utf16_le_attr) {
+  const char text[] =
+      /* <e a='&#228; &#x00E4;'></e> */
+      "<\0e\0 \0a\0=\0'\0&\0#\0\x32\0\x32\0\x38\0;\0 \0"
+      "&\0#\0x\0\x30\0\x30\0E\0\x34\0;\0'\0>\0<\0/\0e\0>\0";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("\x00e4 \x00e4");
+  const XML_Char *expected = XCS("\x00e4 \x00e4");
 #else
-    const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
+  const XML_Char *expected = XCS("\xc3\xa4 \xc3\xa4");
 #endif
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_entity_public_utf16_be)
-{
-    const char text[] =
-        /* <!DOCTYPE d [ */
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
-        /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
-        "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 "
-        "\0'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n"
-        /* %e; */
-        "\0%\0e\0;\0\n"
-        /* ]> */
-        "\0]\0>\0\n"
-        /* <d>&j;</d> */
-        "\0<\0d\0>\0&\0j\0;\0<\0/\0d\0>";
-    ExtTest2 test_data = {
-        /* <!ENTITY j 'baz'> */
-        "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>",
-        34,
-        NULL,
-        NULL,
-        EE_PARSE_NONE
-    };
-    const XML_Char *expected = XCS("baz");
-    CharData storage;
-
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_entity_public_utf16_le)
-{
-    const char text[] =
-        /* <!DOCTYPE d [ */
-        "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n\0"
-        /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
-        "<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 \0"
-        "'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n\0"
-        /* %e; */
-        "%\0e\0;\0\n\0"
-        /* ]> */
-        "]\0>\0\n\0"
-        /* <d>&j;</d> */
-        "<\0d\0>\0&\0j\0;\0<\0/\0d\0>\0";
-    ExtTest2 test_data = {
-        /* <!ENTITY j 'baz'> */
-        "<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>\0",
-        34,
-        NULL,
-        NULL,
-        EE_PARSE_NONE
-    };
-    const XML_Char *expected = XCS("baz");
-    CharData storage;
-
-    CharData_Init(&storage);
-    test_data.storage = &storage;
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_loader2);
-    XML_SetUserData(parser, &test_data);
-    XML_SetCharacterDataHandler(parser, ext2_accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_entity_public_utf16_be) {
+  const char text[] =
+      /* <!DOCTYPE d [ */
+      "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n"
+      /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
+      "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 "
+      "\0'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n"
+      /* %e; */
+      "\0%\0e\0;\0\n"
+      /* ]> */
+      "\0]\0>\0\n"
+      /* <d>&j;</d> */
+      "\0<\0d\0>\0&\0j\0;\0<\0/\0d\0>";
+  ExtTest2 test_data = {/* <!ENTITY j 'baz'> */
+                        "\0<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>",
+                        34, NULL, NULL, EE_PARSE_NONE};
+  const XML_Char *expected = XCS("baz");
+  CharData storage;
+
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_entity_public_utf16_le) {
+  const char text[] =
+      /* <!DOCTYPE d [ */
+      "<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0d\0 \0[\0\n\0"
+      /* <!ENTITY % e PUBLIC 'foo' 'bar.ent'> */
+      "<\0!\0E\0N\0T\0I\0T\0Y\0 \0%\0 \0e\0 \0P\0U\0B\0L\0I\0C\0 \0"
+      "'\0f\0o\0o\0'\0 \0'\0b\0a\0r\0.\0e\0n\0t\0'\0>\0\n\0"
+      /* %e; */
+      "%\0e\0;\0\n\0"
+      /* ]> */
+      "]\0>\0\n\0"
+      /* <d>&j;</d> */
+      "<\0d\0>\0&\0j\0;\0<\0/\0d\0>\0";
+  ExtTest2 test_data = {/* <!ENTITY j 'baz'> */
+                        "<\0!\0E\0N\0T\0I\0T\0Y\0 \0j\0 \0'\0b\0a\0z\0'\0>\0",
+                        34, NULL, NULL, EE_PARSE_NONE};
+  const XML_Char *expected = XCS("baz");
+  CharData storage;
+
+  CharData_Init(&storage);
+  test_data.storage = &storage;
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_loader2);
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetCharacterDataHandler(g_parser, ext2_accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
 /* Test that a doctype with neither an internal nor external subset is
  * faulted
  */
-START_TEST(test_short_doctype)
-{
-    const char *text = "<!DOCTYPE doc></doc>";
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "DOCTYPE without subset not rejected");
+START_TEST(test_short_doctype) {
+  const char *text = "<!DOCTYPE doc></doc>";
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "DOCTYPE without subset not rejected");
 }
 END_TEST
 
-START_TEST(test_short_doctype_2)
-{
-    const char *text = "<!DOCTYPE doc PUBLIC></doc>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "DOCTYPE without Public ID not rejected");
+START_TEST(test_short_doctype_2) {
+  const char *text = "<!DOCTYPE doc PUBLIC></doc>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "DOCTYPE without Public ID not rejected");
 }
 END_TEST
 
-START_TEST(test_short_doctype_3)
-{
-    const char *text = "<!DOCTYPE doc SYSTEM></doc>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "DOCTYPE without System ID not rejected");
+START_TEST(test_short_doctype_3) {
+  const char *text = "<!DOCTYPE doc SYSTEM></doc>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "DOCTYPE without System ID not rejected");
 }
 END_TEST
 
-START_TEST(test_long_doctype)
-{
-    const char *text = "<!DOCTYPE doc PUBLIC 'foo' 'bar' 'baz'></doc>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "DOCTYPE with extra ID not rejected");
+START_TEST(test_long_doctype) {
+  const char *text = "<!DOCTYPE doc PUBLIC 'foo' 'bar' 'baz'></doc>";
+  expect_failure(text, XML_ERROR_SYNTAX, "DOCTYPE with extra ID not rejected");
 }
 END_TEST
 
-START_TEST(test_bad_entity)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY foo PUBLIC>\n"
-        "]>\n"
-        "<doc/>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "ENTITY without Public ID is not rejected");
+START_TEST(test_bad_entity) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY foo PUBLIC>\n"
+                     "]>\n"
+                     "<doc/>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "ENTITY without Public ID is not rejected");
 }
 END_TEST
 
 /* Test unquoted value is faulted */
-START_TEST(test_bad_entity_2)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY % foo bar>\n"
-        "]>\n"
-        "<doc/>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "ENTITY without Public ID is not rejected");
+START_TEST(test_bad_entity_2) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY % foo bar>\n"
+                     "]>\n"
+                     "<doc/>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "ENTITY without Public ID is not rejected");
 }
 END_TEST
 
-START_TEST(test_bad_entity_3)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY % foo PUBLIC>\n"
-        "]>\n"
-        "<doc/>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "Parameter ENTITY without Public ID is not rejected");
+START_TEST(test_bad_entity_3) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY % foo PUBLIC>\n"
+                     "]>\n"
+                     "<doc/>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "Parameter ENTITY without Public ID is not rejected");
 }
 END_TEST
 
-START_TEST(test_bad_entity_4)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY % foo SYSTEM>\n"
-        "]>\n"
-        "<doc/>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "Parameter ENTITY without Public ID is not rejected");
+START_TEST(test_bad_entity_4) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY % foo SYSTEM>\n"
+                     "]>\n"
+                     "<doc/>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "Parameter ENTITY without Public ID is not rejected");
 }
 END_TEST
 
-START_TEST(test_bad_notation)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!NOTATION n SYSTEM>\n"
-        "]>\n"
-        "<doc/>";
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "Notation without System ID is not rejected");
+START_TEST(test_bad_notation) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!NOTATION n SYSTEM>\n"
+                     "]>\n"
+                     "<doc/>";
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "Notation without System ID is not rejected");
 }
 END_TEST
 
 /* Test for issue #11, wrongly suppressed default handler */
 typedef struct default_check {
-    const XML_Char *expected;
-    const int expectedLen;
-    XML_Bool seen;
+  const XML_Char *expected;
+  const int expectedLen;
+  XML_Bool seen;
 } DefaultCheck;
 
 static void XMLCALL
-checking_default_handler(void *userData,
-                         const XML_Char *s,
-                         int len)
-{
-    DefaultCheck *data = (DefaultCheck *)userData;
-    int i;
+checking_default_handler(void *userData, const XML_Char *s, int len) {
+  DefaultCheck *data = (DefaultCheck *)userData;
+  int i;
 
-    for (i = 0; data[i].expected != NULL; i++) {
-        if (data[i].expectedLen == len &&
-            !memcmp(data[i].expected, s, len * sizeof(XML_Char))) {
-            data[i].seen = XML_TRUE;
-            break;
-        }
+  for (i = 0; data[i].expected != NULL; i++) {
+    if (data[i].expectedLen == len
+        && ! memcmp(data[i].expected, s, len * sizeof(XML_Char))) {
+      data[i].seen = XML_TRUE;
+      break;
     }
+  }
 }
 
-START_TEST(test_default_doctype_handler)
-{
-    const char *text =
-        "<!DOCTYPE doc PUBLIC 'pubname' 'test.dtd' [\n"
-        "  <!ENTITY foo 'bar'>\n"
-        "]>\n"
-        "<doc>&foo;</doc>";
-    DefaultCheck test_data[] = {
-        {
-            XCS("'pubname'"),
-            9,
-            XML_FALSE
-        },
-        {
-            XCS("'test.dtd'"),
-            10,
-            XML_FALSE
-        },
-        { NULL, 0, XML_FALSE }
-    };
-    int i;
+START_TEST(test_default_doctype_handler) {
+  const char *text = "<!DOCTYPE doc PUBLIC 'pubname' 'test.dtd' [\n"
+                     "  <!ENTITY foo 'bar'>\n"
+                     "]>\n"
+                     "<doc>&foo;</doc>";
+  DefaultCheck test_data[] = {{XCS("'pubname'"), 9, XML_FALSE},
+                              {XCS("'test.dtd'"), 10, XML_FALSE},
+                              {NULL, 0, XML_FALSE}};
+  int i;
 
-    XML_SetUserData(parser, &test_data);
-    XML_SetDefaultHandler(parser, checking_default_handler);
-    XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    for (i = 0; test_data[i].expected != NULL; i++)
-        if (!test_data[i].seen)
-            fail("Default handler not run for public !DOCTYPE");
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetDefaultHandler(g_parser, checking_default_handler);
+  XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  for (i = 0; test_data[i].expected != NULL; i++)
+    if (! test_data[i].seen)
+      fail("Default handler not run for public !DOCTYPE");
 }
 END_TEST
 
-START_TEST(test_empty_element_abort)
-{
-    const char *text = "<abort/>";
+START_TEST(test_empty_element_abort) {
+  const char *text = "<abort/>";
 
-    XML_SetStartElementHandler(parser, start_element_suspender);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Expected to error on abort");
+  XML_SetStartElementHandler(g_parser, start_element_suspender);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Expected to error on abort");
 }
 END_TEST
 
@@ -7116,17 +6460,15 @@ END_TEST
  */
 
 static void
-namespace_setup(void)
-{
-    parser = XML_ParserCreateNS(NULL, XCS(' '));
-    if (parser == NULL)
-        fail("Parser not created.");
+namespace_setup(void) {
+  g_parser = XML_ParserCreateNS(NULL, XCS(' '));
+  if (g_parser == NULL)
+    fail("Parser not created.");
 }
 
 static void
-namespace_teardown(void)
-{
-    basic_teardown();
+namespace_teardown(void) {
+  basic_teardown();
 }
 
 /* Check that an element name and attribute name match the expected values.
@@ -7139,20 +6481,18 @@ static int triplet_end_flag = XML_FALSE;
 
 static void XMLCALL
 triplet_start_checker(void *userData, const XML_Char *name,
-                      const XML_Char **atts)
-{
-    XML_Char **elemstr = (XML_Char **)userData;
-    char buffer[1024];
-    if (xcstrcmp(elemstr[0], name) != 0) {
-        sprintf(buffer, "unexpected start string: '%" XML_FMT_STR "'", name);
-        fail(buffer);
-    }
-    if (xcstrcmp(elemstr[1], atts[0]) != 0) {
-        sprintf(buffer, "unexpected attribute string: '%" XML_FMT_STR "'",
-                atts[0]);
-        fail(buffer);
-    }
-    triplet_start_flag = XML_TRUE;
+                      const XML_Char **atts) {
+  XML_Char **elemstr = (XML_Char **)userData;
+  char buffer[1024];
+  if (xcstrcmp(elemstr[0], name) != 0) {
+    sprintf(buffer, "unexpected start string: '%" XML_FMT_STR "'", name);
+    fail(buffer);
+  }
+  if (xcstrcmp(elemstr[1], atts[0]) != 0) {
+    sprintf(buffer, "unexpected attribute string: '%" XML_FMT_STR "'", atts[0]);
+    fail(buffer);
+  }
+  triplet_start_flag = XML_TRUE;
 }
 
 /* Check that the element name passed to the end-element handler matches
@@ -7160,382 +6500,344 @@ triplet_start_checker(void *userData, const XML_Char *name,
    in an array of strings passed as the userData argument.
 */
 static void XMLCALL
-triplet_end_checker(void *userData, const XML_Char *name)
-{
-    XML_Char **elemstr = (XML_Char **)userData;
-    if (xcstrcmp(elemstr[0], name) != 0) {
-        char buffer[1024];
-        sprintf(buffer, "unexpected end string: '%" XML_FMT_STR "'", name);
-        fail(buffer);
-    }
-    triplet_end_flag = XML_TRUE;
-}
-
-START_TEST(test_return_ns_triplet)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' bar:a='12'\n"
-        "       xmlns:bar='http://example.org/'>";
-    const char *epilog = "</foo:e>";
-    const XML_Char *elemstr[] = {
-        XCS("http://example.org/ e foo"),
-        XCS("http://example.org/ a bar")
-    };
-    XML_SetReturnNSTriplet(parser, XML_TRUE);
-    XML_SetUserData(parser, (void *)elemstr);
-    XML_SetElementHandler(parser, triplet_start_checker,
-                          triplet_end_checker);
-    XML_SetNamespaceDeclHandler(parser,
-                                dummy_start_namespace_decl_handler,
-                                dummy_end_namespace_decl_handler);
-    triplet_start_flag = XML_FALSE;
-    triplet_end_flag = XML_FALSE;
-    dummy_handler_flags = 0;
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (!triplet_start_flag)
-        fail("triplet_start_checker not invoked");
-    /* Check that unsetting "return triplets" fails while still parsing */
-    XML_SetReturnNSTriplet(parser, XML_FALSE);
-    if (_XML_Parse_SINGLE_BYTES(parser, epilog, (int)strlen(epilog),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (!triplet_end_flag)
-        fail("triplet_end_checker not invoked");
-    if (dummy_handler_flags != (DUMMY_START_NS_DECL_HANDLER_FLAG |
-                                DUMMY_END_NS_DECL_HANDLER_FLAG))
-        fail("Namespace handlers not called");
+triplet_end_checker(void *userData, const XML_Char *name) {
+  XML_Char **elemstr = (XML_Char **)userData;
+  if (xcstrcmp(elemstr[0], name) != 0) {
+    char buffer[1024];
+    sprintf(buffer, "unexpected end string: '%" XML_FMT_STR "'", name);
+    fail(buffer);
+  }
+  triplet_end_flag = XML_TRUE;
+}
+
+START_TEST(test_return_ns_triplet) {
+  const char *text = "<foo:e xmlns:foo='http://example.org/' bar:a='12'\n"
+                     "       xmlns:bar='http://example.org/'>";
+  const char *epilog = "</foo:e>";
+  const XML_Char *elemstr[]
+      = {XCS("http://example.org/ e foo"), XCS("http://example.org/ a bar")};
+  XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+  XML_SetUserData(g_parser, (void *)elemstr);
+  XML_SetElementHandler(g_parser, triplet_start_checker, triplet_end_checker);
+  XML_SetNamespaceDeclHandler(g_parser, dummy_start_namespace_decl_handler,
+                              dummy_end_namespace_decl_handler);
+  triplet_start_flag = XML_FALSE;
+  triplet_end_flag = XML_FALSE;
+  dummy_handler_flags = 0;
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (! triplet_start_flag)
+    fail("triplet_start_checker not invoked");
+  /* Check that unsetting "return triplets" fails while still parsing */
+  XML_SetReturnNSTriplet(g_parser, XML_FALSE);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, epilog, (int)strlen(epilog), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (! triplet_end_flag)
+    fail("triplet_end_checker not invoked");
+  if (dummy_handler_flags
+      != (DUMMY_START_NS_DECL_HANDLER_FLAG | DUMMY_END_NS_DECL_HANDLER_FLAG))
+    fail("Namespace handlers not called");
 }
 END_TEST
 
 static void XMLCALL
 overwrite_start_checker(void *userData, const XML_Char *name,
-                        const XML_Char **atts)
-{
-    CharData *storage = (CharData *) userData;
-    CharData_AppendXMLChars(storage, XCS("start "), 6);
-    CharData_AppendXMLChars(storage, name, -1);
-    while (*atts != NULL) {
-        CharData_AppendXMLChars(storage, XCS("\nattribute "), 11);
-        CharData_AppendXMLChars(storage, *atts, -1);
-        atts += 2;
-    }
-    CharData_AppendXMLChars(storage, XCS("\n"), 1);
+                        const XML_Char **atts) {
+  CharData *storage = (CharData *)userData;
+  CharData_AppendXMLChars(storage, XCS("start "), 6);
+  CharData_AppendXMLChars(storage, name, -1);
+  while (*atts != NULL) {
+    CharData_AppendXMLChars(storage, XCS("\nattribute "), 11);
+    CharData_AppendXMLChars(storage, *atts, -1);
+    atts += 2;
+  }
+  CharData_AppendXMLChars(storage, XCS("\n"), 1);
 }
 
 static void XMLCALL
-overwrite_end_checker(void *userData, const XML_Char *name)
-{
-    CharData *storage = (CharData *) userData;
-    CharData_AppendXMLChars(storage, XCS("end "), 4);
-    CharData_AppendXMLChars(storage, name, -1);
-    CharData_AppendXMLChars(storage, XCS("\n"), 1);
+overwrite_end_checker(void *userData, const XML_Char *name) {
+  CharData *storage = (CharData *)userData;
+  CharData_AppendXMLChars(storage, XCS("end "), 4);
+  CharData_AppendXMLChars(storage, name, -1);
+  CharData_AppendXMLChars(storage, XCS("\n"), 1);
 }
 
 static void
-run_ns_tagname_overwrite_test(const char *text, const XML_Char *result)
-{
-    CharData storage;
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetElementHandler(parser,
-                          overwrite_start_checker, overwrite_end_checker);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, result);
+run_ns_tagname_overwrite_test(const char *text, const XML_Char *result) {
+  CharData storage;
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetElementHandler(g_parser, overwrite_start_checker,
+                        overwrite_end_checker);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, result);
 }
 
 /* Regression test for SF bug #566334. */
-START_TEST(test_ns_tagname_overwrite)
-{
-    const char *text =
-        "<n:e xmlns:n='http://example.org/'>\n"
-        "  <n:f n:attr='foo'/>\n"
-        "  <n:g n:attr2='bar'/>\n"
-        "</n:e>";
-    const XML_Char *result =
-        XCS("start http://example.org/ e\n")
-        XCS("start http://example.org/ f\n")
-        XCS("attribute http://example.org/ attr\n")
-        XCS("end http://example.org/ f\n")
-        XCS("start http://example.org/ g\n")
-        XCS("attribute http://example.org/ attr2\n")
-        XCS("end http://example.org/ g\n")
-        XCS("end http://example.org/ e\n");
-    run_ns_tagname_overwrite_test(text, result);
+START_TEST(test_ns_tagname_overwrite) {
+  const char *text = "<n:e xmlns:n='http://example.org/'>\n"
+                     "  <n:f n:attr='foo'/>\n"
+                     "  <n:g n:attr2='bar'/>\n"
+                     "</n:e>";
+  const XML_Char *result = XCS("start http://example.org/ e\n")
+      XCS("start http://example.org/ f\n")
+          XCS("attribute http://example.org/ attr\n")
+              XCS("end http://example.org/ f\n")
+                  XCS("start http://example.org/ g\n")
+                      XCS("attribute http://example.org/ attr2\n")
+                          XCS("end http://example.org/ g\n")
+                              XCS("end http://example.org/ e\n");
+  run_ns_tagname_overwrite_test(text, result);
 }
 END_TEST
 
 /* Regression test for SF bug #566334. */
-START_TEST(test_ns_tagname_overwrite_triplet)
-{
-    const char *text =
-        "<n:e xmlns:n='http://example.org/'>\n"
-        "  <n:f n:attr='foo'/>\n"
-        "  <n:g n:attr2='bar'/>\n"
-        "</n:e>";
-    const XML_Char *result =
-        XCS("start http://example.org/ e n\n")
-        XCS("start http://example.org/ f n\n")
-        XCS("attribute http://example.org/ attr n\n")
-        XCS("end http://example.org/ f n\n")
-        XCS("start http://example.org/ g n\n")
-        XCS("attribute http://example.org/ attr2 n\n")
-        XCS("end http://example.org/ g n\n")
-        XCS("end http://example.org/ e n\n");
-    XML_SetReturnNSTriplet(parser, XML_TRUE);
-    run_ns_tagname_overwrite_test(text, result);
+START_TEST(test_ns_tagname_overwrite_triplet) {
+  const char *text = "<n:e xmlns:n='http://example.org/'>\n"
+                     "  <n:f n:attr='foo'/>\n"
+                     "  <n:g n:attr2='bar'/>\n"
+                     "</n:e>";
+  const XML_Char *result = XCS("start http://example.org/ e n\n")
+      XCS("start http://example.org/ f n\n")
+          XCS("attribute http://example.org/ attr n\n")
+              XCS("end http://example.org/ f n\n")
+                  XCS("start http://example.org/ g n\n")
+                      XCS("attribute http://example.org/ attr2 n\n")
+                          XCS("end http://example.org/ g n\n")
+                              XCS("end http://example.org/ e n\n");
+  XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+  run_ns_tagname_overwrite_test(text, result);
 }
 END_TEST
 
-
 /* Regression test for SF bug #620343. */
 static void XMLCALL
-start_element_fail(void *UNUSED_P(userData),
-                   const XML_Char *UNUSED_P(name), const XML_Char **UNUSED_P(atts))
-{
-    /* We should never get here. */
-    fail("should never reach start_element_fail()");
+start_element_fail(void *userData, const XML_Char *name,
+                   const XML_Char **atts) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  UNUSED_P(atts);
+
+  /* We should never get here. */
+  fail("should never reach start_element_fail()");
 }
 
 static void XMLCALL
-start_ns_clearing_start_element(void *userData,
-                                const XML_Char *UNUSED_P(prefix),
-                                const XML_Char *UNUSED_P(uri))
-{
-    XML_SetStartElementHandler((XML_Parser) userData, NULL);
+start_ns_clearing_start_element(void *userData, const XML_Char *prefix,
+                                const XML_Char *uri) {
+  UNUSED_P(prefix);
+  UNUSED_P(uri);
+  XML_SetStartElementHandler((XML_Parser)userData, NULL);
 }
 
-START_TEST(test_start_ns_clears_start_element)
-{
-    /* This needs to use separate start/end tags; using the empty tag
-       syntax doesn't cause the problematic path through Expat to be
-       taken.
-    */
-    const char *text = "<e xmlns='http://example.org/'></e>";
+START_TEST(test_start_ns_clears_start_element) {
+  /* This needs to use separate start/end tags; using the empty tag
+     syntax doesn't cause the problematic path through Expat to be
+     taken.
+  */
+  const char *text = "<e xmlns='http://example.org/'></e>";
 
-    XML_SetStartElementHandler(parser, start_element_fail);
-    XML_SetStartNamespaceDeclHandler(parser, start_ns_clearing_start_element);
-    XML_SetEndNamespaceDeclHandler(parser, dummy_end_namespace_decl_handler);
-    XML_UseParserAsHandlerArg(parser);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetStartElementHandler(g_parser, start_element_fail);
+  XML_SetStartNamespaceDeclHandler(g_parser, start_ns_clearing_start_element);
+  XML_SetEndNamespaceDeclHandler(g_parser, dummy_end_namespace_decl_handler);
+  XML_UseParserAsHandlerArg(g_parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Regression test for SF bug #616863. */
 static int XMLCALL
-external_entity_handler(XML_Parser parser,
-                        const XML_Char *context,
-                        const XML_Char *UNUSED_P(base),
-                        const XML_Char *UNUSED_P(systemId),
-                        const XML_Char *UNUSED_P(publicId))
-{
-    intptr_t callno = 1 + (intptr_t)XML_GetUserData(parser);
-    const char *text;
-    XML_Parser p2;
-
-    if (callno == 1)
-        text = ("<!ELEMENT doc (e+)>\n"
-                "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
-                "<!ELEMENT e EMPTY>\n");
-    else
-        text = ("<?xml version='1.0' encoding='us-ascii'?>"
-                "<e/>");
-
-    XML_SetUserData(parser, (void *) callno);
-    p2 = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (_XML_Parse_SINGLE_BYTES(p2, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(p2);
-        return XML_STATUS_ERROR;
-    }
-    XML_ParserFree(p2);
-    return XML_STATUS_OK;
+external_entity_handler(XML_Parser parser, const XML_Char *context,
+                        const XML_Char *base, const XML_Char *systemId,
+                        const XML_Char *publicId) {
+  intptr_t callno = 1 + (intptr_t)XML_GetUserData(parser);
+  const char *text;
+  XML_Parser p2;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  if (callno == 1)
+    text = ("<!ELEMENT doc (e+)>\n"
+            "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
+            "<!ELEMENT e EMPTY>\n");
+  else
+    text = ("<?xml version='1.0' encoding='us-ascii'?>"
+            "<e/>");
+
+  XML_SetUserData(parser, (void *)callno);
+  p2 = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (_XML_Parse_SINGLE_BYTES(p2, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(p2);
+    return XML_STATUS_ERROR;
+  }
+  XML_ParserFree(p2);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_default_ns_from_ext_subset_and_ext_ge)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
-        "]>\n"
-        "<doc xmlns='http://example.org/ns1'>\n"
-        "&en;\n"
-        "</doc>";
+START_TEST(test_default_ns_from_ext_subset_and_ext_ge) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
+                     "]>\n"
+                     "<doc xmlns='http://example.org/ns1'>\n"
+                     "&en;\n"
+                     "</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_handler);
-    /* We actually need to set this handler to tickle this bug. */
-    XML_SetStartElementHandler(parser, dummy_start_element);
-    XML_SetUserData(parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_handler);
+  /* We actually need to set this handler to tickle this bug. */
+  XML_SetStartElementHandler(g_parser, dummy_start_element);
+  XML_SetUserData(g_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Regression test #1 for SF bug #673791. */
-START_TEST(test_ns_prefix_with_empty_uri_1)
-{
-    const char *text =
-        "<doc xmlns:prefix='http://example.org/'>\n"
-        "  <e xmlns:prefix=''/>\n"
-        "</doc>";
+START_TEST(test_ns_prefix_with_empty_uri_1) {
+  const char *text = "<doc xmlns:prefix='http://example.org/'>\n"
+                     "  <e xmlns:prefix=''/>\n"
+                     "</doc>";
 
-    expect_failure(text,
-                   XML_ERROR_UNDECLARING_PREFIX,
-                   "Did not report re-setting namespace"
-                   " URI with prefix to ''.");
+  expect_failure(text, XML_ERROR_UNDECLARING_PREFIX,
+                 "Did not report re-setting namespace"
+                 " URI with prefix to ''.");
 }
 END_TEST
 
 /* Regression test #2 for SF bug #673791. */
-START_TEST(test_ns_prefix_with_empty_uri_2)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<docelem xmlns:pre=''/>";
+START_TEST(test_ns_prefix_with_empty_uri_2) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<docelem xmlns:pre=''/>";
 
-    expect_failure(text,
-                   XML_ERROR_UNDECLARING_PREFIX,
-                   "Did not report setting namespace URI with prefix to ''.");
+  expect_failure(text, XML_ERROR_UNDECLARING_PREFIX,
+                 "Did not report setting namespace URI with prefix to ''.");
 }
 END_TEST
 
 /* Regression test #3 for SF bug #673791. */
-START_TEST(test_ns_prefix_with_empty_uri_3)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ELEMENT doc EMPTY>\n"
-        "  <!ATTLIST doc\n"
-        "    xmlns:prefix CDATA ''>\n"
-        "]>\n"
-        "<doc/>";
+START_TEST(test_ns_prefix_with_empty_uri_3) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ELEMENT doc EMPTY>\n"
+                     "  <!ATTLIST doc\n"
+                     "    xmlns:prefix CDATA ''>\n"
+                     "]>\n"
+                     "<doc/>";
 
-    expect_failure(text,
-                   XML_ERROR_UNDECLARING_PREFIX,
-                   "Didn't report attr default setting NS w/ prefix to ''.");
+  expect_failure(text, XML_ERROR_UNDECLARING_PREFIX,
+                 "Didn't report attr default setting NS w/ prefix to ''.");
 }
 END_TEST
 
 /* Regression test #4 for SF bug #673791. */
-START_TEST(test_ns_prefix_with_empty_uri_4)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ELEMENT prefix:doc EMPTY>\n"
-        "  <!ATTLIST prefix:doc\n"
-        "    xmlns:prefix CDATA 'http://example.org/'>\n"
-        "]>\n"
-        "<prefix:doc/>";
-    /* Packaged info expected by the end element handler;
-       the weird structuring lets us re-use the triplet_end_checker()
-       function also used for another test. */
-    const XML_Char *elemstr[] = {
-        XCS("http://example.org/ doc prefix")
-    };
-    XML_SetReturnNSTriplet(parser, XML_TRUE);
-    XML_SetUserData(parser, (void *)elemstr);
-    XML_SetEndElementHandler(parser, triplet_end_checker);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_ns_prefix_with_empty_uri_4) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ELEMENT prefix:doc EMPTY>\n"
+                     "  <!ATTLIST prefix:doc\n"
+                     "    xmlns:prefix CDATA 'http://example.org/'>\n"
+                     "]>\n"
+                     "<prefix:doc/>";
+  /* Packaged info expected by the end element handler;
+     the weird structuring lets us re-use the triplet_end_checker()
+     function also used for another test. */
+  const XML_Char *elemstr[] = {XCS("http://example.org/ doc prefix")};
+  XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+  XML_SetUserData(g_parser, (void *)elemstr);
+  XML_SetEndElementHandler(g_parser, triplet_end_checker);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test with non-xmlns prefix */
-START_TEST(test_ns_unbound_prefix)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ELEMENT prefix:doc EMPTY>\n"
-        "  <!ATTLIST prefix:doc\n"
-        "    notxmlns:prefix CDATA 'http://example.org/'>\n"
-        "]>\n"
-        "<prefix:doc/>";
+START_TEST(test_ns_unbound_prefix) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ELEMENT prefix:doc EMPTY>\n"
+                     "  <!ATTLIST prefix:doc\n"
+                     "    notxmlns:prefix CDATA 'http://example.org/'>\n"
+                     "]>\n"
+                     "<prefix:doc/>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) != XML_STATUS_ERROR)
-        fail("Unbound prefix incorrectly passed");
-    if (XML_GetErrorCode(parser) != XML_ERROR_UNBOUND_PREFIX)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Unbound prefix incorrectly passed");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_UNBOUND_PREFIX)
+    xml_failure(g_parser);
 }
 END_TEST
 
-START_TEST(test_ns_default_with_empty_uri)
-{
-    const char *text =
-        "<doc xmlns='http://example.org/'>\n"
-        "  <e xmlns=''/>\n"
-        "</doc>";
-    /* Add some handlers to exercise extra code paths */
-    XML_SetStartNamespaceDeclHandler(parser,
-                                     dummy_start_namespace_decl_handler);
-    XML_SetEndNamespaceDeclHandler(parser,
-                                   dummy_end_namespace_decl_handler);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_ns_default_with_empty_uri) {
+  const char *text = "<doc xmlns='http://example.org/'>\n"
+                     "  <e xmlns=''/>\n"
+                     "</doc>";
+  /* Add some handlers to exercise extra code paths */
+  XML_SetStartNamespaceDeclHandler(g_parser,
+                                   dummy_start_namespace_decl_handler);
+  XML_SetEndNamespaceDeclHandler(g_parser, dummy_end_namespace_decl_handler);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Regression test for SF bug #692964: two prefixes for one namespace. */
-START_TEST(test_ns_duplicate_attrs_diff_prefixes)
-{
-    const char *text =
-        "<doc xmlns:a='http://example.org/a'\n"
-        "     xmlns:b='http://example.org/a'\n"
-        "     a:a='v' b:a='v' />";
-    expect_failure(text,
-                   XML_ERROR_DUPLICATE_ATTRIBUTE,
-                   "did not report multiple attributes with same URI+name");
-}
-END_TEST
-
-START_TEST(test_ns_duplicate_hashes)
-{
-    /* The hash of an attribute is calculated as the hash of its URI
-     * concatenated with a space followed by its name (after the
-     * colon).  We wish to generate attributes with the same hash
-     * value modulo the attribute table size so that we can check that
-     * the attribute hash table works correctly.  The attribute hash
-     * table size will be the smallest power of two greater than the
-     * number of attributes, but at least eight.  There is
-     * unfortunately no programmatic way of getting the hash or the
-     * table size at user level, but the test code coverage percentage
-     * will drop if the hashes cease to point to the same row.
-     *
-     * The cunning plan is to have few enough attributes to have a
-     * reliable table size of 8, and have the single letter attribute
-     * names be 8 characters apart, producing a hash which will be the
-     * same modulo 8.
-     */
-    const char *text =
-        "<doc xmlns:a='http://example.org/a'\n"
-        "     a:a='v' a:i='w' />";
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_ns_duplicate_attrs_diff_prefixes) {
+  const char *text = "<doc xmlns:a='http://example.org/a'\n"
+                     "     xmlns:b='http://example.org/a'\n"
+                     "     a:a='v' b:a='v' />";
+  expect_failure(text, XML_ERROR_DUPLICATE_ATTRIBUTE,
+                 "did not report multiple attributes with same URI+name");
+}
+END_TEST
+
+START_TEST(test_ns_duplicate_hashes) {
+  /* The hash of an attribute is calculated as the hash of its URI
+   * concatenated with a space followed by its name (after the
+   * colon).  We wish to generate attributes with the same hash
+   * value modulo the attribute table size so that we can check that
+   * the attribute hash table works correctly.  The attribute hash
+   * table size will be the smallest power of two greater than the
+   * number of attributes, but at least eight.  There is
+   * unfortunately no programmatic way of getting the hash or the
+   * table size at user level, but the test code coverage percentage
+   * will drop if the hashes cease to point to the same row.
+   *
+   * The cunning plan is to have few enough attributes to have a
+   * reliable table size of 8, and have the single letter attribute
+   * names be 8 characters apart, producing a hash which will be the
+   * same modulo 8.
+   */
+  const char *text = "<doc xmlns:a='http://example.org/a'\n"
+                     "     a:a='v' a:i='w' />";
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Regression test for SF bug #695401: unbound prefix. */
-START_TEST(test_ns_unbound_prefix_on_attribute)
-{
-    const char *text = "<doc a:attr=''/>";
-    expect_failure(text,
-                   XML_ERROR_UNBOUND_PREFIX,
-                   "did not report unbound prefix on attribute");
+START_TEST(test_ns_unbound_prefix_on_attribute) {
+  const char *text = "<doc a:attr=''/>";
+  expect_failure(text, XML_ERROR_UNBOUND_PREFIX,
+                 "did not report unbound prefix on attribute");
 }
 END_TEST
 
 /* Regression test for SF bug #695401: unbound prefix. */
-START_TEST(test_ns_unbound_prefix_on_element)
-{
-    const char *text = "<a:doc/>";
-    expect_failure(text,
-                   XML_ERROR_UNBOUND_PREFIX,
-                   "did not report unbound prefix on element");
+START_TEST(test_ns_unbound_prefix_on_element) {
+  const char *text = "<a:doc/>";
+  expect_failure(text, XML_ERROR_UNBOUND_PREFIX,
+                 "did not report unbound prefix on element");
 }
 END_TEST
 
@@ -7543,60 +6845,53 @@ END_TEST
  * We usE test_return_ns_triplet() for our example parse to improve
  * coverage of tidying up code executed.
  */
-START_TEST(test_ns_parser_reset)
-{
-    XML_ParsingStatus status;
-
-    XML_GetParsingStatus(parser, &status);
-    if (status.parsing != XML_INITIALIZED)
-        fail("parsing status doesn't start INITIALIZED");
-    test_return_ns_triplet();
-    XML_GetParsingStatus(parser, &status);
-    if (status.parsing != XML_FINISHED)
-        fail("parsing status doesn't end FINISHED");
-    XML_ParserReset(parser, NULL);
-    XML_GetParsingStatus(parser, &status);
-    if (status.parsing != XML_INITIALIZED)
-        fail("parsing status doesn't reset to INITIALIZED");
+START_TEST(test_ns_parser_reset) {
+  XML_ParsingStatus status;
+
+  XML_GetParsingStatus(g_parser, &status);
+  if (status.parsing != XML_INITIALIZED)
+    fail("parsing status doesn't start INITIALIZED");
+  test_return_ns_triplet();
+  XML_GetParsingStatus(g_parser, &status);
+  if (status.parsing != XML_FINISHED)
+    fail("parsing status doesn't end FINISHED");
+  XML_ParserReset(g_parser, NULL);
+  XML_GetParsingStatus(g_parser, &status);
+  if (status.parsing != XML_INITIALIZED)
+    fail("parsing status doesn't reset to INITIALIZED");
 }
 END_TEST
 
 /* Test that long element names with namespaces are handled correctly */
-START_TEST(test_ns_long_element)
-{
-    const char *text =
-        "<foo:thisisalongenoughelementnametotriggerareallocation\n"
+START_TEST(test_ns_long_element) {
+  const char *text
+      = "<foo:thisisalongenoughelementnametotriggerareallocation\n"
         " xmlns:foo='http://example.org/' bar:a='12'\n"
         " xmlns:bar='http://example.org/'>"
         "</foo:thisisalongenoughelementnametotriggerareallocation>";
-    const XML_Char *elemstr[] = {
-        XCS("http://example.org/")
-        XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
-        XCS("http://example.org/ a bar")
-    };
+  const XML_Char *elemstr[]
+      = {XCS("http://example.org/")
+             XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
+         XCS("http://example.org/ a bar")};
 
-    XML_SetReturnNSTriplet(parser, XML_TRUE);
-    XML_SetUserData(parser, (void *)elemstr);
-    XML_SetElementHandler(parser,
-                          triplet_start_checker,
-                          triplet_end_checker);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+  XML_SetUserData(g_parser, (void *)elemstr);
+  XML_SetElementHandler(g_parser, triplet_start_checker, triplet_end_checker);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test mixed population of prefixed and unprefixed attributes */
-START_TEST(test_ns_mixed_prefix_atts)
-{
-    const char *text =
-        "<e a='12' bar:b='13'\n"
-        " xmlns:bar='http://example.org/'>"
-        "</e>";
+START_TEST(test_ns_mixed_prefix_atts) {
+  const char *text = "<e a='12' bar:b='13'\n"
+                     " xmlns:bar='http://example.org/'>"
+                     "</e>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
@@ -7604,69 +6899,62 @@ END_TEST
  * This exercises some internal buffer reallocation that is shared
  * across elements with the same namespace URI.
  */
-START_TEST(test_ns_extend_uri_buffer)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/'>"
-        " <foo:thisisalongenoughnametotriggerallocationaction"
-        "   foo:a='12' />"
-        "</foo:e>";
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_ns_extend_uri_buffer) {
+  const char *text = "<foo:e xmlns:foo='http://example.org/'>"
+                     " <foo:thisisalongenoughnametotriggerallocationaction"
+                     "   foo:a='12' />"
+                     "</foo:e>";
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test that xmlns is correctly rejected as an attribute in the xmlns
  * namespace, but not in other namespaces
  */
-START_TEST(test_ns_reserved_attributes)
-{
-    const char *text1 =
-        "<foo:e xmlns:foo='http://example.org/' xmlns:xmlns='12' />";
-    const char *text2 =
-        "<foo:e xmlns:foo='http://example.org/' foo:xmlns='12' />";
-    expect_failure(text1, XML_ERROR_RESERVED_PREFIX_XMLNS,
-                   "xmlns not rejected as an attribute");
-    XML_ParserReset(parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+START_TEST(test_ns_reserved_attributes) {
+  const char *text1
+      = "<foo:e xmlns:foo='http://example.org/' xmlns:xmlns='12' />";
+  const char *text2
+      = "<foo:e xmlns:foo='http://example.org/' foo:xmlns='12' />";
+  expect_failure(text1, XML_ERROR_RESERVED_PREFIX_XMLNS,
+                 "xmlns not rejected as an attribute");
+  XML_ParserReset(g_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test more reserved attributes */
-START_TEST(test_ns_reserved_attributes_2)
-{
-    const char *text1 =
-        "<foo:e xmlns:foo='http://example.org/'"
-        "  xmlns:xml='http://example.org/' />";
-    const char *text2 =
-        "<foo:e xmlns:foo='http://www.w3.org/XML/1998/namespace' />";
-    const char *text3 =
-        "<foo:e xmlns:foo='http://www.w3.org/2000/xmlns/' />";
-
-    expect_failure(text1, XML_ERROR_RESERVED_PREFIX_XML,
-                   "xml not rejected as an attribute");
-    XML_ParserReset(parser, NULL);
-    expect_failure(text2, XML_ERROR_RESERVED_NAMESPACE_URI,
-                   "Use of w3.org URL not faulted");
-    XML_ParserReset(parser, NULL);
-    expect_failure(text3, XML_ERROR_RESERVED_NAMESPACE_URI,
-                   "Use of w3.org xmlns URL not faulted");
+START_TEST(test_ns_reserved_attributes_2) {
+  const char *text1 = "<foo:e xmlns:foo='http://example.org/'"
+                      "  xmlns:xml='http://example.org/' />";
+  const char *text2
+      = "<foo:e xmlns:foo='http://www.w3.org/XML/1998/namespace' />";
+  const char *text3 = "<foo:e xmlns:foo='http://www.w3.org/2000/xmlns/' />";
+
+  expect_failure(text1, XML_ERROR_RESERVED_PREFIX_XML,
+                 "xml not rejected as an attribute");
+  XML_ParserReset(g_parser, NULL);
+  expect_failure(text2, XML_ERROR_RESERVED_NAMESPACE_URI,
+                 "Use of w3.org URL not faulted");
+  XML_ParserReset(g_parser, NULL);
+  expect_failure(text3, XML_ERROR_RESERVED_NAMESPACE_URI,
+                 "Use of w3.org xmlns URL not faulted");
 }
 END_TEST
 
 /* Test string pool handling of namespace names of 2048 characters */
 /* Exercises a particular string pool growth path */
-START_TEST(test_ns_extremely_long_prefix)
-{
-    /* C99 compilers are only required to support 4095-character
-     * strings, so the following needs to be split in two to be safe
-     * for all compilers.
-     */
-    const char *text1 =
-        "<doc "
+START_TEST(test_ns_extremely_long_prefix) {
+  /* C99 compilers are only required to support 4095-character
+   * strings, so the following needs to be split in two to be safe
+   * for all compilers.
+   */
+  const char *text1
+      = "<doc "
         /* 64 character on each line */
         /* ...gives a total length of 2048 */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -7702,8 +6990,8 @@ START_TEST(test_ns_extremely_long_prefix)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":a='12'";
-    const char *text2 =
-        " xmlns:"
+  const char *text2
+      = " xmlns:"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -7739,170 +7027,154 @@ START_TEST(test_ns_extremely_long_prefix)
         "='foo'\n>"
         "</doc>";
 
-    if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                XML_FALSE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    if (_XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
 /* Test unknown encoding handlers in namespace setup */
-START_TEST(test_ns_unknown_encoding_success)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='prefix-conv'?>\n"
-        "<foo:e xmlns:foo='http://example.org/'>Hi</foo:e>";
+START_TEST(test_ns_unknown_encoding_success) {
+  const char *text = "<?xml version='1.0' encoding='prefix-conv'?>\n"
+                     "<foo:e xmlns:foo='http://example.org/'>Hi</foo:e>";
 
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    run_character_check(text, XCS("Hi"));
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  run_character_check(text, XCS("Hi"));
 }
 END_TEST
 
 /* Test that too many colons are rejected */
-START_TEST(test_ns_double_colon)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' foo:a:b='bar' />";
+START_TEST(test_ns_double_colon) {
+  const char *text = "<foo:e xmlns:foo='http://example.org/' foo:a:b='bar' />";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Double colon in attribute name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Double colon in attribute name not faulted");
 }
 END_TEST
 
-START_TEST(test_ns_double_colon_element)
-{
-    const char *text =
-        "<foo:bar:e xmlns:foo='http://example.org/' />";
+START_TEST(test_ns_double_colon_element) {
+  const char *text = "<foo:bar:e xmlns:foo='http://example.org/' />";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Double colon in element name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Double colon in element name not faulted");
 }
 END_TEST
 
 /* Test that non-name characters after a colon are rejected */
-START_TEST(test_ns_bad_attr_leafname)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' foo:?ar='baz' />";
+START_TEST(test_ns_bad_attr_leafname) {
+  const char *text = "<foo:e xmlns:foo='http://example.org/' foo:?ar='baz' />";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid character in leafname not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid character in leafname not faulted");
 }
 END_TEST
 
-START_TEST(test_ns_bad_element_leafname)
-{
-    const char *text =
-        "<foo:?oc xmlns:foo='http://example.org/' />";
+START_TEST(test_ns_bad_element_leafname) {
+  const char *text = "<foo:?oc xmlns:foo='http://example.org/' />";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid character in element leafname not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid character in element leafname not faulted");
 }
 END_TEST
 
 /* Test high-byte-set UTF-16 characters are valid in a leafname */
-START_TEST(test_ns_utf16_leafname)
-{
-    const char text[] =
-        /* <n:e xmlns:n='URI' n:{KHO KHWAI}='a' />
-         * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-         */
-        "<\0n\0:\0e\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0 \0"
-        "n\0:\0\x04\x0e=\0'\0a\0'\0 \0/\0>\0";
-    const XML_Char *expected = XCS("a");
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetStartElementHandler(parser, accumulate_attribute);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_ns_utf16_element_leafname)
-{
-    const char text[] =
-        /* <n:{KHO KHWAI} xmlns:n='URI'/>
-         * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-         */
-        "\0<\0n\0:\x0e\x04\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0/\0>";
+START_TEST(test_ns_utf16_leafname) {
+  const char text[] =
+      /* <n:e xmlns:n='URI' n:{KHO KHWAI}='a' />
+       * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+       */
+      "<\0n\0:\0e\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0 \0"
+      "n\0:\0\x04\x0e=\0'\0a\0'\0 \0/\0>\0";
+  const XML_Char *expected = XCS("a");
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetStartElementHandler(g_parser, accumulate_attribute);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_ns_utf16_element_leafname) {
+  const char text[] =
+      /* <n:{KHO KHWAI} xmlns:n='URI'/>
+       * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+       */
+      "\0<\0n\0:\x0e\x04\0 \0x\0m\0l\0n\0s\0:\0n\0=\0'\0U\0R\0I\0'\0/\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("URI \x0e04");
+  const XML_Char *expected = XCS("URI \x0e04");
 #else
-    const XML_Char *expected = XCS("URI \xe0\xb8\x84");
+  const XML_Char *expected = XCS("URI \xe0\xb8\x84");
 #endif
-    CharData storage;
-
-    CharData_Init(&storage);
-    XML_SetStartElementHandler(parser, start_element_event_handler);
-    XML_SetUserData(parser, &storage);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
-}
-END_TEST
-
-START_TEST(test_ns_utf16_doctype)
-{
-    const char text[] =
-        /* <!DOCTYPE foo:{KHO KHWAI} [ <!ENTITY bar 'baz'> ]>\n
-         * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
-         */
-        "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0f\0o\0o\0:\x0e\x04\0 "
-        "\0[\0 \0<\0!\0E\0N\0T\0I\0T\0Y\0 \0b\0a\0r\0 \0'\0b\0a\0z\0'\0>\0 "
-        "\0]\0>\0\n"
-        /* <foo:{KHO KHWAI} xmlns:foo='URI'>&bar;</foo:{KHO KHWAI}> */
-        "\0<\0f\0o\0o\0:\x0e\x04\0 "
-        "\0x\0m\0l\0n\0s\0:\0f\0o\0o\0=\0'\0U\0R\0I\0'\0>"
-        "\0&\0b\0a\0r\0;"
-        "\0<\0/\0f\0o\0o\0:\x0e\x04\0>";
+  CharData storage;
+
+  CharData_Init(&storage);
+  XML_SetStartElementHandler(g_parser, start_element_event_handler);
+  XML_SetUserData(g_parser, &storage);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+START_TEST(test_ns_utf16_doctype) {
+  const char text[] =
+      /* <!DOCTYPE foo:{KHO KHWAI} [ <!ENTITY bar 'baz'> ]>\n
+       * where {KHO KHWAI} = U+0E04 = 0xe0 0xb8 0x84 in UTF-8
+       */
+      "\0<\0!\0D\0O\0C\0T\0Y\0P\0E\0 \0f\0o\0o\0:\x0e\x04\0 "
+      "\0[\0 \0<\0!\0E\0N\0T\0I\0T\0Y\0 \0b\0a\0r\0 \0'\0b\0a\0z\0'\0>\0 "
+      "\0]\0>\0\n"
+      /* <foo:{KHO KHWAI} xmlns:foo='URI'>&bar;</foo:{KHO KHWAI}> */
+      "\0<\0f\0o\0o\0:\x0e\x04\0 "
+      "\0x\0m\0l\0n\0s\0:\0f\0o\0o\0=\0'\0U\0R\0I\0'\0>"
+      "\0&\0b\0a\0r\0;"
+      "\0<\0/\0f\0o\0o\0:\x0e\x04\0>";
 #ifdef XML_UNICODE
-    const XML_Char *expected = XCS("URI \x0e04");
+  const XML_Char *expected = XCS("URI \x0e04");
 #else
-    const XML_Char *expected = XCS("URI \xe0\xb8\x84");
+  const XML_Char *expected = XCS("URI \xe0\xb8\x84");
 #endif
-    CharData storage;
+  CharData storage;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetStartElementHandler(parser, start_element_event_handler);
-    XML_SetUnknownEncodingHandler(parser, MiscEncodingHandler, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetStartElementHandler(g_parser, start_element_event_handler);
+  XML_SetUnknownEncodingHandler(g_parser, MiscEncodingHandler, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 }
 END_TEST
 
-START_TEST(test_ns_invalid_doctype)
-{
-    const char *text =
-        "<!DOCTYPE foo:!bad [ <!ENTITY bar 'baz' ]>\n"
-        "<foo:!bad>&bar;</foo:!bad>";
+START_TEST(test_ns_invalid_doctype) {
+  const char *text = "<!DOCTYPE foo:!bad [ <!ENTITY bar 'baz' ]>\n"
+                     "<foo:!bad>&bar;</foo:!bad>";
 
-    expect_failure(text, XML_ERROR_INVALID_TOKEN,
-                   "Invalid character in document local name not faulted");
+  expect_failure(text, XML_ERROR_INVALID_TOKEN,
+                 "Invalid character in document local name not faulted");
 }
 END_TEST
 
-START_TEST(test_ns_double_colon_doctype)
-{
-    const char *text =
-        "<!DOCTYPE foo:a:doc [ <!ENTITY bar 'baz' ]>\n"
-        "<foo:a:doc>&bar;</foo:a:doc>";
+START_TEST(test_ns_double_colon_doctype) {
+  const char *text = "<!DOCTYPE foo:a:doc [ <!ENTITY bar 'baz' ]>\n"
+                     "<foo:a:doc>&bar;</foo:a:doc>";
 
-    expect_failure(text, XML_ERROR_SYNTAX,
-                   "Double colon in document name not faulted");
+  expect_failure(text, XML_ERROR_SYNTAX,
+                 "Double colon in document name not faulted");
 }
 END_TEST
 
-/* Control variable; the number of times duff_allocator() will successfully allocate */
+/* Control variable; the number of times duff_allocator() will successfully
+ * allocate */
 #define ALLOC_ALWAYS_SUCCEED (-1)
 #define REALLOC_ALWAYS_SUCCEED (-1)
 
@@ -7910,84 +7182,79 @@ static intptr_t allocation_count = ALLOC_ALWAYS_SUCCEED;
 static intptr_t reallocation_count = REALLOC_ALWAYS_SUCCEED;
 
 /* Crocked allocator for allocation failure tests */
-static void *duff_allocator(size_t size)
-{
-    if (allocation_count == 0)
-        return NULL;
-    if (allocation_count != ALLOC_ALWAYS_SUCCEED)
-        allocation_count--;
-    return malloc(size);
+static void *
+duff_allocator(size_t size) {
+  if (allocation_count == 0)
+    return NULL;
+  if (allocation_count != ALLOC_ALWAYS_SUCCEED)
+    allocation_count--;
+  return malloc(size);
 }
 
 /* Crocked reallocator for allocation failure tests */
-static void *duff_reallocator(void *ptr, size_t size)
-{
-    if (reallocation_count == 0)
-        return NULL;
-    if (reallocation_count != REALLOC_ALWAYS_SUCCEED)
-        reallocation_count--;
-    return realloc(ptr, size);
+static void *
+duff_reallocator(void *ptr, size_t size) {
+  if (reallocation_count == 0)
+    return NULL;
+  if (reallocation_count != REALLOC_ALWAYS_SUCCEED)
+    reallocation_count--;
+  return realloc(ptr, size);
 }
 
 /* Test that a failure to allocate the parser structure fails gracefully */
-START_TEST(test_misc_alloc_create_parser)
-{
-    XML_Memory_Handling_Suite memsuite = { duff_allocator, realloc, free };
-    unsigned int i;
-    const unsigned int max_alloc_count = 10;
-
-    /* Something this simple shouldn't need more than 10 allocations */
-    for (i = 0; i < max_alloc_count; i++)
-    {
-        allocation_count = i;
-        parser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
-        if (parser != NULL)
-            break;
-    }
-    if (i == 0)
-        fail("Parser unexpectedly ignored failing allocator");
-    else if (i == max_alloc_count)
-        fail("Parser not created with max allocation count");
+START_TEST(test_misc_alloc_create_parser) {
+  XML_Memory_Handling_Suite memsuite = {duff_allocator, realloc, free};
+  unsigned int i;
+  const unsigned int max_alloc_count = 10;
+
+  /* Something this simple shouldn't need more than 10 allocations */
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    g_parser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
+    if (g_parser != NULL)
+      break;
+  }
+  if (i == 0)
+    fail("Parser unexpectedly ignored failing allocator");
+  else if (i == max_alloc_count)
+    fail("Parser not created with max allocation count");
 }
 END_TEST
 
 /* Test memory allocation failures for a parser with an encoding */
-START_TEST(test_misc_alloc_create_parser_with_encoding)
-{
-    XML_Memory_Handling_Suite memsuite = { duff_allocator, realloc, free };
-    unsigned int i;
-    const unsigned int max_alloc_count = 10;
+START_TEST(test_misc_alloc_create_parser_with_encoding) {
+  XML_Memory_Handling_Suite memsuite = {duff_allocator, realloc, free};
+  unsigned int i;
+  const unsigned int max_alloc_count = 10;
 
-    /* Try several levels of allocation */
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        parser = XML_ParserCreate_MM(XCS("us-ascii"), &memsuite, NULL);
-        if (parser != NULL)
-            break;
-    }
-    if (i == 0)
-        fail("Parser ignored failing allocator");
-    else if (i == max_alloc_count)
-        fail("Parser not created with max allocation count");
+  /* Try several levels of allocation */
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    g_parser = XML_ParserCreate_MM(XCS("us-ascii"), &memsuite, NULL);
+    if (g_parser != NULL)
+      break;
+  }
+  if (i == 0)
+    fail("Parser ignored failing allocator");
+  else if (i == max_alloc_count)
+    fail("Parser not created with max allocation count");
 }
 END_TEST
 
 /* Test that freeing a NULL parser doesn't cause an explosion.
  * (Not actually tested anywhere else)
  */
-START_TEST(test_misc_null_parser)
-{
-    XML_ParserFree(NULL);
+START_TEST(test_misc_null_parser) {
+  XML_ParserFree(NULL);
 }
 END_TEST
 
 /* Test that XML_ErrorString rejects out-of-range codes */
-START_TEST(test_misc_error_string)
-{
-    if (XML_ErrorString((enum XML_Error)-1) != NULL)
-        fail("Negative error code not rejected");
-    if (XML_ErrorString((enum XML_Error)100) != NULL)
-        fail("Large error code not rejected");
+START_TEST(test_misc_error_string) {
+  if (XML_ErrorString((enum XML_Error) - 1) != NULL)
+    fail("Negative error code not rejected");
+  if (XML_ErrorString((enum XML_Error)100) != NULL)
+    fail("Large error code not rejected");
 }
 END_TEST
 
@@ -7999,210 +7266,325 @@ END_TEST
  */
 static int
 parse_version(const XML_LChar *version_text,
-              XML_Expat_Version *version_struct)
-{
-    while (*version_text != 0x00) {
-        if (*version_text >= ASCII_0 && *version_text <= ASCII_9)
-            break;
-        version_text++;
-    }
-    if (*version_text == 0x00)
-        return XML_FALSE;
-
-    /* version_struct->major = strtoul(version_text, 10, &version_text) */
-    version_struct->major = 0;
-    while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
-        version_struct->major =
-            10 * version_struct->major + (*version_text++ - ASCII_0);
-    }
-    if (*version_text++ != ASCII_PERIOD)
-        return XML_FALSE;
-
-    /* Now for the minor version number */
-    version_struct->minor = 0;
-    while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
-        version_struct->minor =
-            10 * version_struct->minor + (*version_text++ - ASCII_0);
-    }
-    if (*version_text++ != ASCII_PERIOD)
-        return XML_FALSE;
-
-    /* Finally the micro version number */
-    version_struct->micro = 0;
-    while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
-        version_struct->micro =
-            10 * version_struct->micro + (*version_text++ - ASCII_0);
-    }
-    if (*version_text != 0x00)
-        return XML_FALSE;
-    return XML_TRUE;
+              XML_Expat_Version *version_struct) {
+  if (! version_text)
+    return XML_FALSE;
+
+  while (*version_text != 0x00) {
+    if (*version_text >= ASCII_0 && *version_text <= ASCII_9)
+      break;
+    version_text++;
+  }
+  if (*version_text == 0x00)
+    return XML_FALSE;
+
+  /* version_struct->major = strtoul(version_text, 10, &version_text) */
+  version_struct->major = 0;
+  while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
+    version_struct->major
+        = 10 * version_struct->major + (*version_text++ - ASCII_0);
+  }
+  if (*version_text++ != ASCII_PERIOD)
+    return XML_FALSE;
+
+  /* Now for the minor version number */
+  version_struct->minor = 0;
+  while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
+    version_struct->minor
+        = 10 * version_struct->minor + (*version_text++ - ASCII_0);
+  }
+  if (*version_text++ != ASCII_PERIOD)
+    return XML_FALSE;
+
+  /* Finally the micro version number */
+  version_struct->micro = 0;
+  while (*version_text >= ASCII_0 && *version_text <= ASCII_9) {
+    version_struct->micro
+        = 10 * version_struct->micro + (*version_text++ - ASCII_0);
+  }
+  if (*version_text != 0x00)
+    return XML_FALSE;
+  return XML_TRUE;
 }
 
 static int
 versions_equal(const XML_Expat_Version *first,
-               const XML_Expat_Version *second)
-{
-    return (first->major == second->major &&
-            first->minor == second->minor &&
-            first->micro == second->micro);
-}
-
-START_TEST(test_misc_version)
-{
-    XML_Expat_Version read_version = XML_ExpatVersionInfo();
-     /* Silence compiler warning with the following assignment */
-    XML_Expat_Version parsed_version = { 0, 0, 0 };
-    const XML_LChar *version_text = XML_ExpatVersion();
-
-    if (version_text == NULL)
-        fail("Could not obtain version text");
-    if (!parse_version(version_text, &parsed_version))
-        fail("Unable to parse version text");
-    if (!versions_equal(&read_version, &parsed_version))
-        fail("Version mismatch");
+               const XML_Expat_Version *second) {
+  return (first->major == second->major && first->minor == second->minor
+          && first->micro == second->micro);
+}
+
+START_TEST(test_misc_version) {
+  XML_Expat_Version read_version = XML_ExpatVersionInfo();
+  /* Silence compiler warning with the following assignment */
+  XML_Expat_Version parsed_version = {0, 0, 0};
+  const XML_LChar *version_text = XML_ExpatVersion();
+
+  if (version_text == NULL)
+    fail("Could not obtain version text");
+  assert(version_text != NULL);
+  if (! parse_version(version_text, &parsed_version))
+    fail("Unable to parse version text");
+  if (! versions_equal(&read_version, &parsed_version))
+    fail("Version mismatch");
 
 #if ! defined(XML_UNICODE) || defined(XML_UNICODE_WCHAR_T)
-    if (xcstrcmp(version_text, XCS("expat_2.2.6")))  /* needs bump on releases */
-        fail("XML_*_VERSION in expat.h out of sync?\n");
+  if (xcstrcmp(version_text, XCS("expat_2.2.9"))) /* needs bump on releases */
+    fail("XML_*_VERSION in expat.h out of sync?\n");
 #else
-    /* If we have XML_UNICODE defined but not XML_UNICODE_WCHAR_T
-     * then XML_LChar is defined as char, for some reason.
-     */
-    if (strcmp(version_text, "expat_2.2.5")) /* needs bump on releases */
-        fail("XML_*_VERSION in expat.h out of sync?\n");
-#endif  /* ! defined(XML_UNICODE) || defined(XML_UNICODE_WCHAR_T) */
+  /* If we have XML_UNICODE defined but not XML_UNICODE_WCHAR_T
+   * then XML_LChar is defined as char, for some reason.
+   */
+  if (strcmp(version_text, "expat_2.2.5")) /* needs bump on releases */
+    fail("XML_*_VERSION in expat.h out of sync?\n");
+#endif /* ! defined(XML_UNICODE) || defined(XML_UNICODE_WCHAR_T) */
 }
 END_TEST
 
 /* Test feature information */
-START_TEST(test_misc_features)
-{
-    const XML_Feature *features = XML_GetFeatureList();
-
-    /* Prevent problems with double-freeing parsers */
-    parser = NULL;
-    if (features == NULL)
-        fail("Failed to get feature information");
+START_TEST(test_misc_features) {
+  const XML_Feature *features = XML_GetFeatureList();
+
+  /* Prevent problems with double-freeing parsers */
+  g_parser = NULL;
+  if (features == NULL) {
+    fail("Failed to get feature information");
+  } else {
     /* Loop through the features checking what we can */
     while (features->feature != XML_FEATURE_END) {
-        switch(features->feature) {
-            case XML_FEATURE_SIZEOF_XML_CHAR:
-                if (features->value != sizeof(XML_Char))
-                    fail("Incorrect size of XML_Char");
-                break;
-            case XML_FEATURE_SIZEOF_XML_LCHAR:
-                if (features->value != sizeof(XML_LChar))
-                    fail("Incorrect size of XML_LChar");
-                break;
-            default:
-                break;
-        }
-        features++;
+      switch (features->feature) {
+      case XML_FEATURE_SIZEOF_XML_CHAR:
+        if (features->value != sizeof(XML_Char))
+          fail("Incorrect size of XML_Char");
+        break;
+      case XML_FEATURE_SIZEOF_XML_LCHAR:
+        if (features->value != sizeof(XML_LChar))
+          fail("Incorrect size of XML_LChar");
+        break;
+      default:
+        break;
+      }
+      features++;
     }
+  }
 }
 END_TEST
 
 /* Regression test for GitHub Issue #17: memory leak parsing attribute
  * values with mixed bound and unbound namespaces.
  */
-START_TEST(test_misc_attribute_leak)
-{
-    const char *text = "<D xmlns:L=\"D\" l:a='' L:a=''/>";
-    XML_Memory_Handling_Suite memsuite = {
-        tracking_malloc,
-        tracking_realloc,
-        tracking_free
-    };
-
-    parser = XML_ParserCreate_MM(XCS("UTF-8"), &memsuite, XCS("\n"));
-    expect_failure(text, XML_ERROR_UNBOUND_PREFIX,
-                   "Unbound prefixes not found");
-    XML_ParserFree(parser);
-    /* Prevent the teardown trying to double free */
-    parser = NULL;
+START_TEST(test_misc_attribute_leak) {
+  const char *text = "<D xmlns:L=\"D\" l:a='' L:a=''/>";
+  XML_Memory_Handling_Suite memsuite
+      = {tracking_malloc, tracking_realloc, tracking_free};
+
+  g_parser = XML_ParserCreate_MM(XCS("UTF-8"), &memsuite, XCS("\n"));
+  expect_failure(text, XML_ERROR_UNBOUND_PREFIX, "Unbound prefixes not found");
+  XML_ParserFree(g_parser);
+  /* Prevent the teardown trying to double free */
+  g_parser = NULL;
 
-    if (!tracking_report())
-        fail("Memory leak found");
+  if (! tracking_report())
+    fail("Memory leak found");
 }
 END_TEST
 
 /* Test parser created for UTF-16LE is successful */
-START_TEST(test_misc_utf16le)
-{
-    const char text[] =
-        /* <?xml version='1.0'?><q>Hi</q> */
-        "<\0?\0x\0m\0l\0 \0"
-        "v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0?\0>\0"
-        "<\0q\0>\0H\0i\0<\0/\0q\0>\0";
-    const XML_Char *expected = XCS("Hi");
-    CharData storage;
-
-    parser = XML_ParserCreate(XCS("UTF-16LE"));
-    if (parser == NULL)
-        fail("Parser not created");
+START_TEST(test_misc_utf16le) {
+  const char text[] =
+      /* <?xml version='1.0'?><q>Hi</q> */
+      "<\0?\0x\0m\0l\0 \0"
+      "v\0e\0r\0s\0i\0o\0n\0=\0'\0\x31\0.\0\x30\0'\0?\0>\0"
+      "<\0q\0>\0H\0i\0<\0/\0q\0>\0";
+  const XML_Char *expected = XCS("Hi");
+  CharData storage;
+
+  g_parser = XML_ParserCreate(XCS("UTF-16LE"));
+  if (g_parser == NULL)
+    fail("Parser not created");
+
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)sizeof(text) - 1, XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
+}
+END_TEST
+
+typedef struct {
+  XML_Parser parser;
+  int deep;
+} DataIssue240;
 
-    CharData_Init(&storage);
-    XML_SetUserData(parser, &storage);
-    XML_SetCharacterDataHandler(parser, accumulate_characters);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)sizeof(text)-1,
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-    CharData_CheckXMLChars(&storage, expected);
+static void
+start_element_issue_240(void *userData, const XML_Char *name,
+                        const XML_Char **atts) {
+  DataIssue240 *mydata = (DataIssue240 *)userData;
+  UNUSED_P(name);
+  UNUSED_P(atts);
+  mydata->deep++;
 }
-END_TEST
-
 
 static void
-alloc_setup(void)
-{
-    XML_Memory_Handling_Suite memsuite = {
-        duff_allocator,
-        duff_reallocator,
-        free
-    };
-
-    /* Ensure the parser creation will go through */
-    allocation_count = ALLOC_ALWAYS_SUCCEED;
-    reallocation_count = REALLOC_ALWAYS_SUCCEED;
-    parser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
-    if (parser == NULL)
-        fail("Parser not created");
+end_element_issue_240(void *userData, const XML_Char *name) {
+  DataIssue240 *mydata = (DataIssue240 *)userData;
+
+  UNUSED_P(name);
+  mydata->deep--;
+  if (mydata->deep == 0) {
+    XML_StopParser(mydata->parser, 0);
+  }
+}
+
+START_TEST(test_misc_stop_during_end_handler_issue_240_1) {
+  XML_Parser parser;
+  DataIssue240 *mydata;
+  enum XML_Status result;
+  const char *const doc1 = "<doc><e1/><e><foo/></e></doc>";
+
+  parser = XML_ParserCreate(NULL);
+  XML_SetElementHandler(parser, start_element_issue_240, end_element_issue_240);
+  mydata = (DataIssue240 *)malloc(sizeof(DataIssue240));
+  mydata->parser = parser;
+  mydata->deep = 0;
+  XML_SetUserData(parser, mydata);
+
+  result = XML_Parse(parser, doc1, (int)strlen(doc1), 1);
+  XML_ParserFree(parser);
+  free(mydata);
+  if (result != XML_STATUS_ERROR)
+    fail("Stopping the parser did not work as expected");
+}
+END_TEST
+
+START_TEST(test_misc_stop_during_end_handler_issue_240_2) {
+  XML_Parser parser;
+  DataIssue240 *mydata;
+  enum XML_Status result;
+  const char *const doc2 = "<doc><elem/></doc>";
+
+  parser = XML_ParserCreate(NULL);
+  XML_SetElementHandler(parser, start_element_issue_240, end_element_issue_240);
+  mydata = (DataIssue240 *)malloc(sizeof(DataIssue240));
+  mydata->parser = parser;
+  mydata->deep = 0;
+  XML_SetUserData(parser, mydata);
+
+  result = XML_Parse(parser, doc2, (int)strlen(doc2), 1);
+  XML_ParserFree(parser);
+  free(mydata);
+  if (result != XML_STATUS_ERROR)
+    fail("Stopping the parser did not work as expected");
+}
+END_TEST
+
+#ifdef XML_DTD
+START_TEST(test_misc_deny_internal_entity_closing_doctype_issue_317) {
+  const char *const inputOne = "<!DOCTYPE d [\n"
+                               "<!ENTITY % e ']><d/>'>\n"
+                               "\n"
+                               "%e;";
+  const char *const inputTwo = "<!DOCTYPE d [\n"
+                               "<!ENTITY % e1 ']><d/>'><!ENTITY % e2 '&e1;'>\n"
+                               "\n"
+                               "%e2;";
+  const char *const inputThree = "<!DOCTYPE d [\n"
+                                 "<!ENTITY % e ']><d'>\n"
+                                 "\n"
+                                 "%e;";
+  const char *const inputIssue317 = "<!DOCTYPE doc [\n"
+                                    "<!ENTITY % foo ']>\n"
+                                    "<doc>Hell<oc (#PCDATA)*>'>\n"
+                                    "%foo;\n"
+                                    "]>\n"
+                                    "<doc>Hello, world</dVc>";
+
+  const char *const inputs[] = {inputOne, inputTwo, inputThree, inputIssue317};
+  size_t inputIndex = 0;
+
+  for (; inputIndex < sizeof(inputs) / sizeof(inputs[0]); inputIndex++) {
+    XML_Parser parser;
+    enum XML_Status parseResult;
+    int setParamEntityResult;
+    XML_Size lineNumber;
+    XML_Size columnNumber;
+    const char *const input = inputs[inputIndex];
+
+    parser = XML_ParserCreate(NULL);
+    setParamEntityResult
+        = XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    if (setParamEntityResult != 1)
+      fail("Failed to set XML_PARAM_ENTITY_PARSING_ALWAYS.");
+
+    parseResult = XML_Parse(parser, input, (int)strlen(input), 0);
+    if (parseResult != XML_STATUS_ERROR) {
+      parseResult = XML_Parse(parser, "", 0, 1);
+      if (parseResult != XML_STATUS_ERROR) {
+        fail("Parsing was expected to fail but succeeded.");
+      }
+    }
+
+    if (XML_GetErrorCode(parser) != XML_ERROR_INVALID_TOKEN)
+      fail("Error code does not match XML_ERROR_INVALID_TOKEN");
+
+    lineNumber = XML_GetCurrentLineNumber(parser);
+    if (lineNumber != 4)
+      fail("XML_GetCurrentLineNumber does not work as expected.");
+
+    columnNumber = XML_GetCurrentColumnNumber(parser);
+    if (columnNumber != 0)
+      fail("XML_GetCurrentColumnNumber does not work as expected.");
+
+    XML_ParserFree(parser);
+  }
 }
+END_TEST
+#endif
 
 static void
-alloc_teardown(void)
-{
-    basic_teardown();
+alloc_setup(void) {
+  XML_Memory_Handling_Suite memsuite = {duff_allocator, duff_reallocator, free};
+
+  /* Ensure the parser creation will go through */
+  allocation_count = ALLOC_ALWAYS_SUCCEED;
+  reallocation_count = REALLOC_ALWAYS_SUCCEED;
+  g_parser = XML_ParserCreate_MM(NULL, &memsuite, NULL);
+  if (g_parser == NULL)
+    fail("Parser not created");
 }
 
+static void
+alloc_teardown(void) {
+  basic_teardown();
+}
 
 /* Test the effects of allocation failures on xml declaration processing */
-START_TEST(test_alloc_parse_xdecl)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<doc>Hello, world</doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetXmlDeclHandler(parser, dummy_xdecl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* Resetting the parser is insufficient, because some memory
-         * allocations are cached within the parser.  Instead we use
-         * the teardown and setup routines to ensure that we have the
-         * right sort of parser back in our hands.
-         */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
+START_TEST(test_alloc_parse_xdecl) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<doc>Hello, world</doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* Resetting the parser is insufficient, because some memory
+     * allocations are cached within the parser.  Instead we use
+     * the teardown and setup routines to ensure that we have the
+     * right sort of parser back in our hands.
+     */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
 }
 END_TEST
 
@@ -8210,24 +7592,23 @@ END_TEST
  * version information to expand the string pool being used.
  */
 static int XMLCALL
-long_encoding_handler(void *UNUSED_P(userData),
-                      const XML_Char *UNUSED_P(encoding),
-                      XML_Encoding *info)
-{
-    int i;
-
-    for (i = 0; i < 256; i++)
-        info->map[i] = i;
-    info->data = NULL;
-    info->convert = NULL;
-    info->release = NULL;
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_alloc_parse_xdecl_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='"
+long_encoding_handler(void *userData, const XML_Char *encoding,
+                      XML_Encoding *info) {
+  int i;
+
+  UNUSED_P(userData);
+  UNUSED_P(encoding);
+  for (i = 0; i < 256; i++)
+    info->map[i] = i;
+  info->data = NULL;
+  info->convert = NULL;
+  info->release = NULL;
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_alloc_parse_xdecl_2) {
+  const char *text
+      = "<?xml version='1.0' encoding='"
         /* Each line is 64 characters */
         "ThisIsAStupidlyLongEncodingNameIntendedToTriggerPoolGrowth123456"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -8247,88 +7628,83 @@ START_TEST(test_alloc_parse_xdecl_2)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN"
         "'?>"
         "<doc>Hello, world</doc>";
-    int i;
-    const int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetXmlDeclHandler(parser, dummy_xdecl_handler);
-        XML_SetUnknownEncodingHandler(parser, long_encoding_handler, NULL);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
+  int i;
+  const int max_alloc_count = 20;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetXmlDeclHandler(g_parser, dummy_xdecl_handler);
+    XML_SetUnknownEncodingHandler(g_parser, long_encoding_handler, NULL);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
 }
 END_TEST
 
 /* Test the effects of allocation failures on a straightforward parse */
-START_TEST(test_alloc_parse_pi)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<?pi unknown?>\n"
-        "<doc>"
-        "Hello, world"
-        "</doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
-}
-END_TEST
-
-START_TEST(test_alloc_parse_pi_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<doc>"
-        "Hello, world"
-        "<?pi unknown?>\n"
-        "</doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
-}
-END_TEST
-
-START_TEST(test_alloc_parse_pi_3)
-{
-    const char *text =
-        "<?"
+START_TEST(test_alloc_parse_pi) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<?pi unknown?>\n"
+                     "<doc>"
+                     "Hello, world"
+                     "</doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_pi_2) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<doc>"
+                     "Hello, world"
+                     "<?pi unknown?>\n"
+                     "</doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_pi_3) {
+  const char *text
+      = "<?"
         /* 64 characters per line */
         "This processing instruction should be long enough to ensure that"
         "it triggers the growth of an internal string pool when the      "
@@ -8347,684 +7723,635 @@ START_TEST(test_alloc_parse_pi_3)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "Q?><doc/>";
-    int i;
-    const int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
-}
-END_TEST
-
-START_TEST(test_alloc_parse_comment)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<!-- Test parsing this comment -->"
-        "<doc>Hi</doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetCommentHandler(parser, dummy_comment_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
-}
-END_TEST
-
-START_TEST(test_alloc_parse_comment_2)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
-        "<doc>"
-        "Hello, world"
-        "<!-- Parse this comment too -->"
-        "</doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetCommentHandler(parser, dummy_comment_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed with max allocations");
+  int i;
+  const int max_alloc_count = 20;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_comment) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<!-- Test parsing this comment -->"
+                     "<doc>Hi</doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetCommentHandler(g_parser, dummy_comment_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_comment_2) {
+  const char *text = "<?xml version='1.0' encoding='utf-8'?>\n"
+                     "<doc>"
+                     "Hello, world"
+                     "<!-- Parse this comment too -->"
+                     "</doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetCommentHandler(g_parser, dummy_comment_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed with max allocations");
 }
 END_TEST
 
 static int XMLCALL
-external_entity_duff_loader(XML_Parser parser,
-                            const XML_Char *context,
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    XML_Parser new_parser;
-    unsigned int i;
-    const unsigned int max_alloc_count = 10;
-
-    /* Try a few different allocation levels */
-    for (i = 0; i < max_alloc_count; i++)
-    {
-        allocation_count = i;
-        new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-        if (new_parser != NULL)
-        {
-            XML_ParserFree(new_parser);
-            break;
-        }
-    }
-    if (i == 0)
-        fail("External parser creation ignored failing allocator");
-    else if (i == max_alloc_count)
-        fail("Extern parser not created with max allocation count");
-
-    /* Make sure other random allocation doesn't now fail */
-    allocation_count = ALLOC_ALWAYS_SUCCEED;
-
-    /* Make sure the failure code path is executed too */
-    return XML_STATUS_ERROR;
+external_entity_duff_loader(XML_Parser parser, const XML_Char *context,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  XML_Parser new_parser;
+  unsigned int i;
+  const unsigned int max_alloc_count = 10;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  /* Try a few different allocation levels */
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+    if (new_parser != NULL) {
+      XML_ParserFree(new_parser);
+      break;
+    }
+  }
+  if (i == 0)
+    fail("External parser creation ignored failing allocator");
+  else if (i == max_alloc_count)
+    fail("Extern parser not created with max allocation count");
+
+  /* Make sure other random allocation doesn't now fail */
+  allocation_count = ALLOC_ALWAYS_SUCCEED;
+
+  /* Make sure the failure code path is executed too */
+  return XML_STATUS_ERROR;
 }
 
 /* Test that external parser creation running out of memory is
  * correctly reported.  Based on the external entity test cases.
  */
-START_TEST(test_alloc_create_external_parser)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    char foo_text[] =
-        "<!ELEMENT doc (#PCDATA)*>";
-
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetUserData(parser, foo_text);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_duff_loader);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR) {
-        fail("External parser allocator returned success incorrectly");
-    }
+START_TEST(test_alloc_create_external_parser) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  char foo_text[] = "<!ELEMENT doc (#PCDATA)*>";
+
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetUserData(g_parser, foo_text);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_duff_loader);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR) {
+    fail("External parser allocator returned success incorrectly");
+  }
 }
 END_TEST
 
 /* More external parser memory allocation testing */
-START_TEST(test_alloc_run_external_parser)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc>&entity;</doc>";
-    char foo_text[] =
-        "<!ELEMENT doc (#PCDATA)*>";
-    unsigned int i;
-    const unsigned int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        XML_SetParamEntityParsing(parser,
-                                  XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetUserData(parser, foo_text);
-        XML_SetExternalEntityRefHandler(parser,
-                                        external_entity_null_loader);
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing ignored failing allocator");
-    else if (i == max_alloc_count)
-        fail("Parsing failed with allocation count 10");
+START_TEST(test_alloc_run_external_parser) {
+  const char *text = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'foo'>\n"
+                     "<doc>&entity;</doc>";
+  char foo_text[] = "<!ELEMENT doc (#PCDATA)*>";
+  unsigned int i;
+  const unsigned int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetUserData(g_parser, foo_text);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_null_loader);
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing ignored failing allocator");
+  else if (i == max_alloc_count)
+    fail("Parsing failed with allocation count 10");
 }
 END_TEST
 
-
 static int XMLCALL
-external_entity_dbl_handler(XML_Parser parser,
-                            const XML_Char *context,
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    intptr_t callno = (intptr_t)XML_GetUserData(parser);
-    const char *text;
-    XML_Parser new_parser;
-    int i;
-    const int max_alloc_count = 20;
-
-    if (callno == 0) {
-        /* First time through, check how many calls to malloc occur */
-        text = ("<!ELEMENT doc (e+)>\n"
-                "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
-                "<!ELEMENT e EMPTY>\n");
-        allocation_count = 10000;
-        new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-        if (new_parser == NULL) {
-            fail("Unable to allocate first external parser");
-            return XML_STATUS_ERROR;
-        }
-        /* Stash the number of calls in the user data */
-        XML_SetUserData(parser, (void *)(intptr_t)(10000 - allocation_count));
-    } else {
-        text = ("<?xml version='1.0' encoding='us-ascii'?>"
-                "<e/>");
-        /* Try at varying levels to exercise more code paths */
-        for (i = 0; i < max_alloc_count; i++) {
-            allocation_count = callno + i;
-            new_parser = XML_ExternalEntityParserCreate(parser,
-                                                        context,
-                                                        NULL);
-            if (new_parser != NULL)
-                break;
-        }
-        if (i == 0) {
-            fail("Second external parser unexpectedly created");
-            XML_ParserFree(new_parser);
-            return XML_STATUS_ERROR;
-        }
-        else if (i == max_alloc_count) {
-            fail("Second external parser not created");
-            return XML_STATUS_ERROR;
-        }
-    }
-
-    allocation_count = ALLOC_ALWAYS_SUCCEED;
-    if (_XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR) {
-        xml_failure(new_parser);
-        return XML_STATUS_ERROR;
-    }
-    XML_ParserFree(new_parser);
-    return XML_STATUS_OK;
+external_entity_dbl_handler(XML_Parser parser, const XML_Char *context,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  intptr_t callno = (intptr_t)XML_GetUserData(parser);
+  const char *text;
+  XML_Parser new_parser;
+  int i;
+  const int max_alloc_count = 20;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  if (callno == 0) {
+    /* First time through, check how many calls to malloc occur */
+    text = ("<!ELEMENT doc (e+)>\n"
+            "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
+            "<!ELEMENT e EMPTY>\n");
+    allocation_count = 10000;
+    new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+    if (new_parser == NULL) {
+      fail("Unable to allocate first external parser");
+      return XML_STATUS_ERROR;
+    }
+    /* Stash the number of calls in the user data */
+    XML_SetUserData(parser, (void *)(intptr_t)(10000 - allocation_count));
+  } else {
+    text = ("<?xml version='1.0' encoding='us-ascii'?>"
+            "<e/>");
+    /* Try at varying levels to exercise more code paths */
+    for (i = 0; i < max_alloc_count; i++) {
+      allocation_count = callno + i;
+      new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+      if (new_parser != NULL)
+        break;
+    }
+    if (i == 0) {
+      fail("Second external parser unexpectedly created");
+      XML_ParserFree(new_parser);
+      return XML_STATUS_ERROR;
+    } else if (i == max_alloc_count) {
+      fail("Second external parser not created");
+      return XML_STATUS_ERROR;
+    }
+  }
+
+  allocation_count = ALLOC_ALWAYS_SUCCEED;
+  if (_XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR) {
+    xml_failure(new_parser);
+    return XML_STATUS_ERROR;
+  }
+  XML_ParserFree(new_parser);
+  return XML_STATUS_OK;
 }
 
 /* Test that running out of memory in dtdCopy is correctly reported.
  * Based on test_default_ns_from_ext_subset_and_ext_ge()
  */
-START_TEST(test_alloc_dtd_copy_default_atts)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
-        "]>\n"
-        "<doc xmlns='http://example.org/ns1'>\n"
-        "&en;\n"
-        "</doc>";
+START_TEST(test_alloc_dtd_copy_default_atts) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
+                     "]>\n"
+                     "<doc xmlns='http://example.org/ns1'>\n"
+                     "&en;\n"
+                     "</doc>";
 
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser,
-                                    external_entity_dbl_handler);
-    XML_SetUserData(parser, NULL);
-    if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_dbl_handler);
+  XML_SetUserData(g_parser, NULL);
+  if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
 }
 END_TEST
 
-
 static int XMLCALL
-external_entity_dbl_handler_2(XML_Parser parser,
-                              const XML_Char *context,
-                              const XML_Char *UNUSED_P(base),
-                              const XML_Char *UNUSED_P(systemId),
-                              const XML_Char *UNUSED_P(publicId))
-{
-    intptr_t callno = (intptr_t)XML_GetUserData(parser);
-    const char *text;
-    XML_Parser new_parser;
-    enum XML_Status rv;
-
-    if (callno == 0) {
-        /* Try different allocation levels for whole exercise */
-        text = ("<!ELEMENT doc (e+)>\n"
-                "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
-                "<!ELEMENT e EMPTY>\n");
-        XML_SetUserData(parser, (void *)(intptr_t)1);
-        new_parser = XML_ExternalEntityParserCreate(parser,
-                                                    context,
-                                                    NULL);
-        if (new_parser == NULL)
-            return XML_STATUS_ERROR;
-        rv = _XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text),
-                                     XML_TRUE);
-    } else {
-        /* Just run through once */
-        text = ("<?xml version='1.0' encoding='us-ascii'?>"
-                "<e/>");
-        new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-        if (new_parser == NULL)
-            return XML_STATUS_ERROR;
-        rv =_XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text),
-                                    XML_TRUE);
-    }
-    XML_ParserFree(new_parser);
-    if (rv == XML_STATUS_ERROR)
-        return XML_STATUS_ERROR;
-    return XML_STATUS_OK;
+external_entity_dbl_handler_2(XML_Parser parser, const XML_Char *context,
+                              const XML_Char *base, const XML_Char *systemId,
+                              const XML_Char *publicId) {
+  intptr_t callno = (intptr_t)XML_GetUserData(parser);
+  const char *text;
+  XML_Parser new_parser;
+  enum XML_Status rv;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  if (callno == 0) {
+    /* Try different allocation levels for whole exercise */
+    text = ("<!ELEMENT doc (e+)>\n"
+            "<!ATTLIST doc xmlns CDATA #IMPLIED>\n"
+            "<!ELEMENT e EMPTY>\n");
+    XML_SetUserData(parser, (void *)(intptr_t)1);
+    new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+    if (new_parser == NULL)
+      return XML_STATUS_ERROR;
+    rv = _XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text), XML_TRUE);
+  } else {
+    /* Just run through once */
+    text = ("<?xml version='1.0' encoding='us-ascii'?>"
+            "<e/>");
+    new_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+    if (new_parser == NULL)
+      return XML_STATUS_ERROR;
+    rv = _XML_Parse_SINGLE_BYTES(new_parser, text, (int)strlen(text), XML_TRUE);
+  }
+  XML_ParserFree(new_parser);
+  if (rv == XML_STATUS_ERROR)
+    return XML_STATUS_ERROR;
+  return XML_STATUS_OK;
 }
 
 /* Test more external entity allocation failure paths */
-START_TEST(test_alloc_external_entity)
-{
-    const char *text =
-        "<?xml version='1.0'?>\n"
-        "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
-        "]>\n"
-        "<doc xmlns='http://example.org/ns1'>\n"
-        "&en;\n"
-        "</doc>";
-    int i;
-    const int alloc_test_max_repeats = 50;
-
-    for (i = 0; i < alloc_test_max_repeats; i++) {
-        allocation_count = -1;
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser,
-                                        external_entity_dbl_handler_2);
-        XML_SetUserData(parser, NULL);
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) == XML_STATUS_OK)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
+START_TEST(test_alloc_external_entity) {
+  const char *text = "<?xml version='1.0'?>\n"
+                     "<!DOCTYPE doc SYSTEM 'http://example.org/doc.dtd' [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/entity.ent'>\n"
+                     "]>\n"
+                     "<doc xmlns='http://example.org/ns1'>\n"
+                     "&en;\n"
+                     "</doc>";
+  int i;
+  const int alloc_test_max_repeats = 50;
+
+  for (i = 0; i < alloc_test_max_repeats; i++) {
     allocation_count = -1;
-    if (i == 0)
-        fail("External entity parsed despite duff allocator");
-    if (i == alloc_test_max_repeats)
-        fail("External entity not parsed at max allocation count");
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_dbl_handler_2);
+    XML_SetUserData(g_parser, NULL);
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        == XML_STATUS_OK)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  allocation_count = -1;
+  if (i == 0)
+    fail("External entity parsed despite duff allocator");
+  if (i == alloc_test_max_repeats)
+    fail("External entity not parsed at max allocation count");
 }
 END_TEST
 
 /* Test more allocation failure paths */
 static int XMLCALL
-external_entity_alloc_set_encoding(XML_Parser parser,
-                                   const XML_Char *context,
-                                   const XML_Char *UNUSED_P(base),
-                                   const XML_Char *UNUSED_P(systemId),
-                                   const XML_Char *UNUSED_P(publicId))
-{
-    /* As for external_entity_loader() */
-    const char *text =
-        "<?xml encoding='iso-8859-3'?>"
-        "\xC3\xA9";
-    XML_Parser ext_parser;
-    enum XML_Status status;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        return XML_STATUS_ERROR;
-    if (!XML_SetEncoding(ext_parser, XCS("utf-8"))) {
-        XML_ParserFree(ext_parser);
-        return XML_STATUS_ERROR;
-    }
-    status = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                     XML_TRUE);
+external_entity_alloc_set_encoding(XML_Parser parser, const XML_Char *context,
+                                   const XML_Char *base,
+                                   const XML_Char *systemId,
+                                   const XML_Char *publicId) {
+  /* As for external_entity_loader() */
+  const char *text = "<?xml encoding='iso-8859-3'?>"
+                     "\xC3\xA9";
+  XML_Parser ext_parser;
+  enum XML_Status status;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    return XML_STATUS_ERROR;
+  if (! XML_SetEncoding(ext_parser, XCS("utf-8"))) {
     XML_ParserFree(ext_parser);
-    if (status == XML_STATUS_ERROR)
-        return XML_STATUS_ERROR;
-    return XML_STATUS_OK;
-}
-
-START_TEST(test_alloc_ext_entity_set_encoding)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    int i;
-    const int max_allocation_count = 30;
-
-    for (i = 0; i < max_allocation_count; i++) {
-        XML_SetExternalEntityRefHandler(parser,
-                                        external_entity_alloc_set_encoding);
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) == XML_STATUS_OK)
-            break;
-        allocation_count = -1;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Encoding check succeeded despite failing allocator");
-    if (i == max_allocation_count)
-        fail("Encoding failed at max allocation count");
+    return XML_STATUS_ERROR;
+  }
+  status
+      = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE);
+  XML_ParserFree(ext_parser);
+  if (status == XML_STATUS_ERROR)
+    return XML_STATUS_ERROR;
+  return XML_STATUS_OK;
+}
+
+START_TEST(test_alloc_ext_entity_set_encoding) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  int i;
+  const int max_allocation_count = 30;
+
+  for (i = 0; i < max_allocation_count; i++) {
+    XML_SetExternalEntityRefHandler(g_parser,
+                                    external_entity_alloc_set_encoding);
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        == XML_STATUS_OK)
+      break;
+    allocation_count = -1;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Encoding check succeeded despite failing allocator");
+  if (i == max_allocation_count)
+    fail("Encoding failed at max allocation count");
 }
 END_TEST
 
 static int XMLCALL
-unknown_released_encoding_handler(void *UNUSED_P(data),
-                                  const XML_Char *encoding,
-                                  XML_Encoding *info)
-{
-    if (!xcstrcmp(encoding, XCS("unsupported-encoding"))) {
-        int i;
-
-        for (i = 0; i < 256; i++)
-            info->map[i] = i;
-        info->data = NULL;
-        info->convert = NULL;
-        info->release = dummy_release;
-        return XML_STATUS_OK;
-    }
-    return XML_STATUS_ERROR;
+unknown_released_encoding_handler(void *data, const XML_Char *encoding,
+                                  XML_Encoding *info) {
+  UNUSED_P(data);
+  if (! xcstrcmp(encoding, XCS("unsupported-encoding"))) {
+    int i;
+
+    for (i = 0; i < 256; i++)
+      info->map[i] = i;
+    info->data = NULL;
+    info->convert = NULL;
+    info->release = dummy_release;
+    return XML_STATUS_OK;
+  }
+  return XML_STATUS_ERROR;
 }
 
 /* Test the effects of allocation failure in internal entities.
  * Based on test_unknown_encoding_internal_entity
  */
-START_TEST(test_alloc_internal_entity)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
-        "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
-        "<test a='&foo;'/>";
-    unsigned int i;
-    const unsigned int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUnknownEncodingHandler(parser,
-                                      unknown_released_encoding_handler,
-                                      NULL);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Internal entity worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Internal entity failed at max allocation count");
+START_TEST(test_alloc_internal_entity) {
+  const char *text = "<?xml version='1.0' encoding='unsupported-encoding'?>\n"
+                     "<!DOCTYPE test [<!ENTITY foo 'bar'>]>\n"
+                     "<test a='&foo;'/>";
+  unsigned int i;
+  const unsigned int max_alloc_count = 20;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUnknownEncodingHandler(g_parser, unknown_released_encoding_handler,
+                                  NULL);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Internal entity worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Internal entity failed at max allocation count");
 }
 END_TEST
 
-
 /* Test the robustness against allocation failure of element handling
  * Based on test_dtd_default_handling().
  */
-START_TEST(test_alloc_dtd_default_handling)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
-        "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
-        "<!ENTITY e1 SYSTEM 'http://example.org/e' NDATA n>\n"
-        "<!ELEMENT doc (#PCDATA)>\n"
-        "<!ATTLIST doc a CDATA #IMPLIED>\n"
-        "<?pi in dtd?>\n"
-        "<!--comment in dtd-->\n"
-        "]>\n"
-        "<doc><![CDATA[text in doc]]></doc>";
-    const XML_Char *expected = XCS("\n\n\n\n\n\n\n\n\n<doc>text in doc</doc>");
-    CharData storage;
-    int i;
-    const int max_alloc_count = 25;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetDefaultHandler(parser, accumulate_characters);
-        XML_SetDoctypeDeclHandler(parser,
-                                  dummy_start_doctype_handler,
-                                  dummy_end_doctype_handler);
-        XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-        XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-        XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-        XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-        XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-        XML_SetCommentHandler(parser, dummy_comment_handler);
-        XML_SetCdataSectionHandler(parser,
-                                   dummy_start_cdata_handler,
-                                   dummy_end_cdata_handler);
-        XML_SetUnparsedEntityDeclHandler(
-            parser,
-            dummy_unparsed_entity_decl_handler);
-        CharData_Init(&storage);
-        XML_SetUserData(parser, &storage);
-        XML_SetCharacterDataHandler(parser, accumulate_characters);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Default DTD parsed despite allocation failures");
-    if (i == max_alloc_count)
-        fail("Default DTD not parsed with maximum alloc count");
-    CharData_CheckXMLChars(&storage, expected);
-    if (dummy_handler_flags != (DUMMY_START_DOCTYPE_HANDLER_FLAG |
-                                DUMMY_END_DOCTYPE_HANDLER_FLAG |
-                                DUMMY_ENTITY_DECL_HANDLER_FLAG |
-                                DUMMY_NOTATION_DECL_HANDLER_FLAG |
-                                DUMMY_ELEMENT_DECL_HANDLER_FLAG |
-                                DUMMY_ATTLIST_DECL_HANDLER_FLAG |
-                                DUMMY_COMMENT_HANDLER_FLAG |
-                                DUMMY_PI_HANDLER_FLAG |
-                                DUMMY_START_CDATA_HANDLER_FLAG |
-                                DUMMY_END_CDATA_HANDLER_FLAG |
-                                DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG))
-        fail("Not all handlers were called");
+START_TEST(test_alloc_dtd_default_handling) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ENTITY e SYSTEM 'http://example.org/e'>\n"
+                     "<!NOTATION n SYSTEM 'http://example.org/n'>\n"
+                     "<!ENTITY e1 SYSTEM 'http://example.org/e' NDATA n>\n"
+                     "<!ELEMENT doc (#PCDATA)>\n"
+                     "<!ATTLIST doc a CDATA #IMPLIED>\n"
+                     "<?pi in dtd?>\n"
+                     "<!--comment in dtd-->\n"
+                     "]>\n"
+                     "<doc><![CDATA[text in doc]]></doc>";
+  const XML_Char *expected = XCS("\n\n\n\n\n\n\n\n\n<doc>text in doc</doc>");
+  CharData storage;
+  int i;
+  const int max_alloc_count = 25;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetDefaultHandler(g_parser, accumulate_characters);
+    XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_handler,
+                              dummy_end_doctype_handler);
+    XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+    XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+    XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+    XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+    XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+    XML_SetCommentHandler(g_parser, dummy_comment_handler);
+    XML_SetCdataSectionHandler(g_parser, dummy_start_cdata_handler,
+                               dummy_end_cdata_handler);
+    XML_SetUnparsedEntityDeclHandler(g_parser,
+                                     dummy_unparsed_entity_decl_handler);
+    CharData_Init(&storage);
+    XML_SetUserData(g_parser, &storage);
+    XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Default DTD parsed despite allocation failures");
+  if (i == max_alloc_count)
+    fail("Default DTD not parsed with maximum alloc count");
+  CharData_CheckXMLChars(&storage, expected);
+  if (dummy_handler_flags
+      != (DUMMY_START_DOCTYPE_HANDLER_FLAG | DUMMY_END_DOCTYPE_HANDLER_FLAG
+          | DUMMY_ENTITY_DECL_HANDLER_FLAG | DUMMY_NOTATION_DECL_HANDLER_FLAG
+          | DUMMY_ELEMENT_DECL_HANDLER_FLAG | DUMMY_ATTLIST_DECL_HANDLER_FLAG
+          | DUMMY_COMMENT_HANDLER_FLAG | DUMMY_PI_HANDLER_FLAG
+          | DUMMY_START_CDATA_HANDLER_FLAG | DUMMY_END_CDATA_HANDLER_FLAG
+          | DUMMY_UNPARSED_ENTITY_DECL_HANDLER_FLAG))
+    fail("Not all handlers were called");
 }
 END_TEST
 
 /* Test robustness of XML_SetEncoding() with a failing allocator */
-START_TEST(test_alloc_explicit_encoding)
-{
-    int i;
-    const int max_alloc_count = 5;
+START_TEST(test_alloc_explicit_encoding) {
+  int i;
+  const int max_alloc_count = 5;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (XML_SetEncoding(parser, XCS("us-ascii")) == XML_STATUS_OK)
-            break;
-    }
-    if (i == 0)
-        fail("Encoding set despite failing allocator");
-    else if (i == max_alloc_count)
-        fail("Encoding not set at max allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (XML_SetEncoding(g_parser, XCS("us-ascii")) == XML_STATUS_OK)
+      break;
+  }
+  if (i == 0)
+    fail("Encoding set despite failing allocator");
+  else if (i == max_alloc_count)
+    fail("Encoding not set at max allocation count");
 }
 END_TEST
 
 /* Test robustness of XML_SetBase against a failing allocator */
-START_TEST(test_alloc_set_base)
-{
-    const XML_Char *new_base = XCS("/local/file/name.xml");
-    int i;
-    const int max_alloc_count = 5;
+START_TEST(test_alloc_set_base) {
+  const XML_Char *new_base = XCS("/local/file/name.xml");
+  int i;
+  const int max_alloc_count = 5;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (XML_SetBase(parser, new_base) == XML_STATUS_OK)
-            break;
-    }
-    if (i == 0)
-        fail("Base set despite failing allocator");
-    else if (i == max_alloc_count)
-        fail("Base not set with max allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (XML_SetBase(g_parser, new_base) == XML_STATUS_OK)
+      break;
+  }
+  if (i == 0)
+    fail("Base set despite failing allocator");
+  else if (i == max_alloc_count)
+    fail("Base not set with max allocation count");
 }
 END_TEST
 
 /* Test buffer extension in the face of a duff reallocator */
-START_TEST(test_alloc_realloc_buffer)
-{
-    const char *text = get_buffer_test_text;
-    void *buffer;
-    int i;
-    const int max_realloc_count = 10;
-
-    /* Get a smallish buffer */
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        buffer = XML_GetBuffer(parser, 1536);
-        if (buffer == NULL)
-            fail("1.5K buffer reallocation failed");
-        memcpy(buffer, text, strlen(text));
-        if (XML_ParseBuffer(parser, (int)strlen(text),
-                            XML_FALSE) == XML_STATUS_OK)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    reallocation_count = -1;
-    if (i == 0)
-        fail("Parse succeeded with no reallocation");
-    else if (i == max_realloc_count)
-        fail("Parse failed with max reallocation count");
+START_TEST(test_alloc_realloc_buffer) {
+  const char *text = get_buffer_test_text;
+  void *buffer;
+  int i;
+  const int max_realloc_count = 10;
+
+  /* Get a smallish buffer */
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    buffer = XML_GetBuffer(g_parser, 1536);
+    if (buffer == NULL)
+      fail("1.5K buffer reallocation failed");
+    assert(buffer != NULL);
+    memcpy(buffer, text, strlen(text));
+    if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_FALSE)
+        == XML_STATUS_OK)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  reallocation_count = -1;
+  if (i == 0)
+    fail("Parse succeeded with no reallocation");
+  else if (i == max_realloc_count)
+    fail("Parse failed with max reallocation count");
 }
 END_TEST
 
 /* Same test for external entity parsers */
 static int XMLCALL
-external_entity_reallocator(XML_Parser parser,
-                            const XML_Char *context,
-                            const XML_Char *UNUSED_P(base),
-                            const XML_Char *UNUSED_P(systemId),
-                            const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = get_buffer_test_text;
-    XML_Parser ext_parser;
-    void *buffer;
-    enum XML_Status status;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity parser");
-
-    reallocation_count = (intptr_t)XML_GetUserData(parser);
-    buffer = XML_GetBuffer(ext_parser, 1536);
-    if (buffer == NULL)
-        fail("Buffer allocation failed");
-    memcpy(buffer, text, strlen(text));
-    status = XML_ParseBuffer(ext_parser, (int)strlen(text), XML_FALSE);
-    reallocation_count = -1;
-    XML_ParserFree(ext_parser);
-    return (status == XML_STATUS_OK) ? XML_STATUS_OK : XML_STATUS_ERROR;
-}
-
-START_TEST(test_alloc_ext_entity_realloc_buffer)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
-        "]>\n"
-        "<doc>&en;</doc>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        XML_SetExternalEntityRefHandler(parser,
-                                        external_entity_reallocator);
-        XML_SetUserData(parser, (void *)(intptr_t)i);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) == XML_STATUS_OK)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Succeeded with no reallocations");
-    if (i == max_realloc_count)
-        fail("Failed with max reallocations");
+external_entity_reallocator(XML_Parser parser, const XML_Char *context,
+                            const XML_Char *base, const XML_Char *systemId,
+                            const XML_Char *publicId) {
+  const char *text = get_buffer_test_text;
+  XML_Parser ext_parser;
+  void *buffer;
+  enum XML_Status status;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    fail("Could not create external entity parser");
+
+  reallocation_count = (intptr_t)XML_GetUserData(parser);
+  buffer = XML_GetBuffer(ext_parser, 1536);
+  if (buffer == NULL)
+    fail("Buffer allocation failed");
+  assert(buffer != NULL);
+  memcpy(buffer, text, strlen(text));
+  status = XML_ParseBuffer(ext_parser, (int)strlen(text), XML_FALSE);
+  reallocation_count = -1;
+  XML_ParserFree(ext_parser);
+  return (status == XML_STATUS_OK) ? XML_STATUS_OK : XML_STATUS_ERROR;
+}
+
+START_TEST(test_alloc_ext_entity_realloc_buffer) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY en SYSTEM 'http://example.org/dummy.ent'>\n"
+                     "]>\n"
+                     "<doc>&en;</doc>";
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_reallocator);
+    XML_SetUserData(g_parser, (void *)(intptr_t)i);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        == XML_STATUS_OK)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Succeeded with no reallocations");
+  if (i == max_realloc_count)
+    fail("Failed with max reallocations");
 }
 END_TEST
 
 /* Test elements with many attributes are handled correctly */
-START_TEST(test_alloc_realloc_many_attributes)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ATTLIST doc za CDATA 'default'>\n"
-        "<!ATTLIST doc zb CDATA 'def2'>\n"
-        "<!ATTLIST doc zc CDATA 'def3'>\n"
-        "]>\n"
-        "<doc a='1'"
-        "     b='2'"
-        "     c='3'"
-        "     d='4'"
-        "     e='5'"
-        "     f='6'"
-        "     g='7'"
-        "     h='8'"
-        "     i='9'"
-        "     j='10'"
-        "     k='11'"
-        "     l='12'"
-        "     m='13'"
-        "     n='14'"
-        "     p='15'"
-        "     q='16'"
-        "     r='17'"
-        "     s='18'>"
-        "</doc>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite no reallocations");
-    if (i == max_realloc_count)
-        fail("Parse failed at max reallocations");
+START_TEST(test_alloc_realloc_many_attributes) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ATTLIST doc za CDATA 'default'>\n"
+                     "<!ATTLIST doc zb CDATA 'def2'>\n"
+                     "<!ATTLIST doc zc CDATA 'def3'>\n"
+                     "]>\n"
+                     "<doc a='1'"
+                     "     b='2'"
+                     "     c='3'"
+                     "     d='4'"
+                     "     e='5'"
+                     "     f='6'"
+                     "     g='7'"
+                     "     h='8'"
+                     "     i='9'"
+                     "     j='10'"
+                     "     k='11'"
+                     "     l='12'"
+                     "     m='13'"
+                     "     n='14'"
+                     "     p='15'"
+                     "     q='16'"
+                     "     r='17'"
+                     "     s='18'>"
+                     "</doc>";
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite no reallocations");
+  if (i == max_realloc_count)
+    fail("Parse failed at max reallocations");
 }
 END_TEST
 
 /* Test handling of a public entity with failing allocator */
-START_TEST(test_alloc_public_entity_value)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc></doc>\n";
-    char dtd_text[] =
-        "<!ELEMENT doc EMPTY>\n"
+START_TEST(test_alloc_public_entity_value) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc></doc>\n";
+  char dtd_text[]
+      = "<!ELEMENT doc EMPTY>\n"
         "<!ENTITY % e1 PUBLIC 'foo' 'bar.ent'>\n"
         "<!ENTITY % "
         /* Each line is 64 characters */
@@ -9046,40 +8373,38 @@ START_TEST(test_alloc_public_entity_value)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         " '%e1;'>\n"
         "%e1;\n";
-    int i;
-    const int max_alloc_count = 50;
+  int i;
+  const int max_alloc_count = 50;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_public);
-        /* Provoke a particular code path */
-        XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocation");
-    if (i == max_alloc_count)
-        fail("Parsing failed at max allocation count");
-    if (dummy_handler_flags != DUMMY_ENTITY_DECL_HANDLER_FLAG)
-        fail("Entity declaration handler not called");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_subst_public_entity_value)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc></doc>\n";
-    char dtd_text[] =
-        "<!ELEMENT doc EMPTY>\n"
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
+    /* Provoke a particular code path */
+    XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocation");
+  if (i == max_alloc_count)
+    fail("Parsing failed at max allocation count");
+  if (dummy_handler_flags != DUMMY_ENTITY_DECL_HANDLER_FLAG)
+    fail("Entity declaration handler not called");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_subst_public_entity_value) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc></doc>\n";
+  char dtd_text[]
+      = "<!ELEMENT doc EMPTY>\n"
         "<!ENTITY % "
         /* Each line is 64 characters */
         "ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
@@ -9115,32 +8440,31 @@ START_TEST(test_alloc_realloc_subst_public_entity_value)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP;";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_public);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocation");
-    if (i == max_realloc_count)
-        fail("Parsing failed at max reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_parse_public_doctype)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_public);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocation");
+  if (i == max_realloc_count)
+    fail("Parsing failed at max reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_public_doctype) {
+  const char *text
+      = "<?xml version='1.0' encoding='utf-8'?>\n"
         "<!DOCTYPE doc PUBLIC '"
         /* 64 characters per line */
         "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
@@ -9161,36 +8485,35 @@ START_TEST(test_alloc_parse_public_doctype)
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "' 'test'>\n"
         "<doc></doc>";
-    int i;
-    const int max_alloc_count = 25;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetDoctypeDeclHandler(parser,
-                                  dummy_start_doctype_decl_handler,
-                                  dummy_end_doctype_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != (DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG |
-                                DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG))
-        fail("Doctype handler functions not called");
-}
-END_TEST
+  int i;
+  const int max_alloc_count = 25;
 
-START_TEST(test_alloc_parse_public_doctype_long_name)
-{
-    const char *text =
-        "<?xml version='1.0' encoding='utf-8'?>\n"
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_decl_handler,
+                              dummy_end_doctype_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags
+      != (DUMMY_START_DOCTYPE_DECL_HANDLER_FLAG
+          | DUMMY_END_DOCTYPE_DECL_HANDLER_FLAG))
+    fail("Doctype handler functions not called");
+}
+END_TEST
+
+START_TEST(test_alloc_parse_public_doctype_long_name) {
+  const char *text
+      = "<?xml version='1.0' encoding='utf-8'?>\n"
         "<!DOCTYPE doc PUBLIC 'http://example.com/foo' '"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
@@ -9211,128 +8534,120 @@ START_TEST(test_alloc_parse_public_doctype_long_name)
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "'>\n"
         "<doc></doc>";
-    int i;
-    const int max_alloc_count = 25;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetDoctypeDeclHandler(parser,
-                                  dummy_start_doctype_decl_handler,
-                                  dummy_end_doctype_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+  int i;
+  const int max_alloc_count = 25;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetDoctypeDeclHandler(g_parser, dummy_start_doctype_decl_handler,
+                              dummy_end_doctype_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
 static int XMLCALL
-external_entity_alloc(XML_Parser parser,
-                      const XML_Char *context,
-                      const XML_Char *UNUSED_P(base),
-                      const XML_Char *UNUSED_P(systemId),
-                      const XML_Char *UNUSED_P(publicId))
-{
-    const char *text = (const char *)XML_GetUserData(parser);
-    XML_Parser ext_parser;
-    int parse_res;
-
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        return XML_STATUS_ERROR;
-    parse_res = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text),
-                                        XML_TRUE);
-    XML_ParserFree(ext_parser);
-    return parse_res;
+external_entity_alloc(XML_Parser parser, const XML_Char *context,
+                      const XML_Char *base, const XML_Char *systemId,
+                      const XML_Char *publicId) {
+  const char *text = (const char *)XML_GetUserData(parser);
+  XML_Parser ext_parser;
+  int parse_res;
+
+  UNUSED_P(base);
+  UNUSED_P(systemId);
+  UNUSED_P(publicId);
+  ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
+  if (ext_parser == NULL)
+    return XML_STATUS_ERROR;
+  parse_res
+      = _XML_Parse_SINGLE_BYTES(ext_parser, text, (int)strlen(text), XML_TRUE);
+  XML_ParserFree(ext_parser);
+  return parse_res;
 }
 
 /* Test foreign DTD handling */
-START_TEST(test_alloc_set_foreign_dtd)
-{
-    const char *text1 =
-        "<?xml version='1.0' encoding='us-ascii'?>\n"
-        "<doc>&entity;</doc>";
-    char text2[] = "<!ELEMENT doc (#PCDATA)*>";
-    int i;
-    const int max_alloc_count = 25;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetUserData(parser, &text2);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (XML_UseForeignDTD(parser, XML_TRUE) != XML_ERROR_NONE)
-            fail("Could not set foreign DTD");
-        if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+START_TEST(test_alloc_set_foreign_dtd) {
+  const char *text1 = "<?xml version='1.0' encoding='us-ascii'?>\n"
+                      "<doc>&entity;</doc>";
+  char text2[] = "<!ELEMENT doc (#PCDATA)*>";
+  int i;
+  const int max_alloc_count = 25;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetUserData(g_parser, &text2);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (XML_UseForeignDTD(g_parser, XML_TRUE) != XML_ERROR_NONE)
+      fail("Could not set foreign DTD");
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
 /* Test based on ibm/valid/P32/ibm32v04.xml */
-START_TEST(test_alloc_attribute_enum_value)
-{
-    const char *text =
-        "<?xml version='1.0' standalone='no'?>\n"
-        "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
-        "<animal>This is a \n    <a/>  \n\nyellow tiger</animal>";
-    char dtd_text[] =
-        "<!ELEMENT animal (#PCDATA|a)*>\n"
-        "<!ELEMENT a EMPTY>\n"
-        "<!ATTLIST animal xml:space (default|preserve) 'preserve'>";
-    int i;
-    const int max_alloc_count = 30;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        /* An attribute list handler provokes a different code path */
-        XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+START_TEST(test_alloc_attribute_enum_value) {
+  const char *text = "<?xml version='1.0' standalone='no'?>\n"
+                     "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
+                     "<animal>This is a \n    <a/>  \n\nyellow tiger</animal>";
+  char dtd_text[] = "<!ELEMENT animal (#PCDATA|a)*>\n"
+                    "<!ELEMENT a EMPTY>\n"
+                    "<!ATTLIST animal xml:space (default|preserve) 'preserve'>";
+  int i;
+  const int max_alloc_count = 30;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    /* An attribute list handler provokes a different code path */
+    XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
 /* Test attribute enums sufficient to overflow the string pool */
-START_TEST(test_alloc_realloc_attribute_enum_value)
-{
-    const char *text =
-        "<?xml version='1.0' standalone='no'?>\n"
-        "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
-        "<animal>This is a yellow tiger</animal>";
-    /* We wish to define a collection of attribute enums that will
-     * cause the string pool storing them to have to expand.  This
-     * means more than 1024 bytes, including the parentheses and
-     * separator bars.
-     */
-    char dtd_text[] =
-        "<!ELEMENT animal (#PCDATA)*>\n"
+START_TEST(test_alloc_realloc_attribute_enum_value) {
+  const char *text = "<?xml version='1.0' standalone='no'?>\n"
+                     "<!DOCTYPE animal SYSTEM 'test.dtd'>\n"
+                     "<animal>This is a yellow tiger</animal>";
+  /* We wish to define a collection of attribute enums that will
+   * cause the string pool storing them to have to expand.  This
+   * means more than 1024 bytes, including the parentheses and
+   * separator bars.
+   */
+  char dtd_text[]
+      = "<!ELEMENT animal (#PCDATA)*>\n"
         "<!ATTLIST animal thing "
         "(default"
         /* Each line is 64 characters */
@@ -9353,40 +8668,39 @@ START_TEST(test_alloc_realloc_attribute_enum_value)
         "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO)"
         " 'default'>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        /* An attribute list handler provokes a different code path */
-        XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    /* An attribute list handler provokes a different code path */
+    XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
 }
 END_TEST
 
 /* Test attribute enums in a #IMPLIED attribute forcing pool growth */
-START_TEST(test_alloc_realloc_implied_attribute)
-{
-    /* Forcing this particular code path is a balancing act.  The
-     * addition of the closing parenthesis and terminal NUL must be
-     * what pushes the string of enums over the 1024-byte limit,
-     * otherwise a different code path will pick up the realloc.
-     */
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_alloc_realloc_implied_attribute) {
+  /* Forcing this particular code path is a balancing act.  The
+   * addition of the closing parenthesis and terminal NUL must be
+   * what pushes the string of enums over the 1024-byte limit,
+   * otherwise a different code path will pick up the realloc.
+   */
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ELEMENT doc EMPTY>\n"
         "<!ATTLIST doc a "
         /* Each line is 64 characters */
@@ -9408,36 +8722,35 @@ START_TEST(test_alloc_realloc_implied_attribute)
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
         " #IMPLIED>\n"
         "]><doc/>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
 }
 END_TEST
 
 /* Test attribute enums in a defaulted attribute forcing pool growth */
-START_TEST(test_alloc_realloc_default_attribute)
-{
-    /* Forcing this particular code path is a balancing act.  The
-     * addition of the closing parenthesis and terminal NUL must be
-     * what pushes the string of enums over the 1024-byte limit,
-     * otherwise a different code path will pick up the realloc.
-     */
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_alloc_realloc_default_attribute) {
+  /* Forcing this particular code path is a balancing act.  The
+   * addition of the closing parenthesis and terminal NUL must be
+   * what pushes the string of enums over the 1024-byte limit,
+   * otherwise a different code path will pick up the realloc.
+   */
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ELEMENT doc EMPTY>\n"
         "<!ATTLIST doc a "
         /* Each line is 64 characters */
@@ -9459,31 +8772,30 @@ START_TEST(test_alloc_realloc_default_attribute)
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
         " 'ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO'"
         ">\n]><doc/>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetAttlistDeclHandler(parser, dummy_attlist_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetAttlistDeclHandler(g_parser, dummy_attlist_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
 }
 END_TEST
 
 /* Test long notation name with dodgy allocator */
-START_TEST(test_alloc_notation)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_alloc_notation) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!NOTATION "
         /* Each line is 64 characters */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -9523,36 +8835,35 @@ START_TEST(test_alloc_notation)
         ">\n"
         "<!ELEMENT doc EMPTY>\n"
         "]>\n<doc/>";
-    int i;
-    const int max_alloc_count = 20;
+  int i;
+  const int max_alloc_count = 20;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-        XML_SetEntityDeclHandler(parser, dummy_entity_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite allocation failures");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != (DUMMY_ENTITY_DECL_HANDLER_FLAG |
-                                DUMMY_NOTATION_DECL_HANDLER_FLAG))
-        fail("Entity declaration handler not called");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+    XML_SetEntityDeclHandler(g_parser, dummy_entity_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite allocation failures");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags
+      != (DUMMY_ENTITY_DECL_HANDLER_FLAG | DUMMY_NOTATION_DECL_HANDLER_FLAG))
+    fail("Entity declaration handler not called");
 }
 END_TEST
 
 /* Test public notation with dodgy allocator */
-START_TEST(test_alloc_public_notation)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_alloc_public_notation) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!NOTATION note PUBLIC '"
         /* 64 characters per line */
         "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
@@ -9575,34 +8886,33 @@ START_TEST(test_alloc_public_notation)
         "<!ENTITY e SYSTEM 'http://example.com/e' NDATA note>\n"
         "<!ELEMENT doc EMPTY>\n"
         "]>\n<doc/>";
-    int i;
-    const int max_alloc_count = 20;
+  int i;
+  const int max_alloc_count = 20;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite allocation failures");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
-        fail("Notation handler not called");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite allocation failures");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
+    fail("Notation handler not called");
 }
 END_TEST
 
 /* Test public notation with dodgy allocator */
-START_TEST(test_alloc_system_notation)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+START_TEST(test_alloc_system_notation) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!NOTATION note SYSTEM '"
         /* 64 characters per line */
         "http://example.com/a/long/enough/name/to/trigger/pool/growth/zz/"
@@ -9625,33 +8935,32 @@ START_TEST(test_alloc_system_notation)
         "<!ENTITY e SYSTEM 'http://example.com/e' NDATA note>\n"
         "<!ELEMENT doc EMPTY>\n"
         "]>\n<doc/>";
-    int i;
-    const int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        dummy_handler_flags = 0;
-        XML_SetNotationDeclHandler(parser, dummy_notation_decl_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite allocation failures");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
-        fail("Notation handler not called");
-}
-END_TEST
+  int i;
+  const int max_alloc_count = 20;
 
-START_TEST(test_alloc_nested_groups)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    dummy_handler_flags = 0;
+    XML_SetNotationDeclHandler(g_parser, dummy_notation_decl_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite allocation failures");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags != DUMMY_NOTATION_DECL_HANDLER_FLAG)
+    fail("Notation handler not called");
+}
+END_TEST
+
+START_TEST(test_alloc_nested_groups) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ELEMENT doc "
         /* Sixteen elements per line */
         "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
@@ -9660,39 +8969,38 @@ START_TEST(test_alloc_nested_groups)
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
-    int i;
-    const int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        CharData_Init(&storage);
-        XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-        XML_SetStartElementHandler(parser, record_element_start_handler);
-        XML_SetUserData(parser, &storage);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum reallocation count");
-    CharData_CheckXMLChars(&storage, XCS("doce"));
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler not fired");
-}
-END_TEST
+  CharData storage;
+  int i;
+  const int max_alloc_count = 20;
 
-START_TEST(test_alloc_realloc_nested_groups)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    CharData_Init(&storage);
+    XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+    XML_SetStartElementHandler(g_parser, record_element_start_handler);
+    XML_SetUserData(g_parser, &storage);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum reallocation count");
+  CharData_CheckXMLChars(&storage, XCS("doce"));
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler not fired");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_nested_groups) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "<!ELEMENT doc "
         /* Sixteen elements per line */
         "(e,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,"
@@ -9701,173 +9009,164 @@ START_TEST(test_alloc_realloc_nested_groups)
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        CharData_Init(&storage);
-        XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-        XML_SetStartElementHandler(parser, record_element_start_handler);
-        XML_SetUserData(parser, &storage);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-    CharData_CheckXMLChars(&storage, XCS("doce"));
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler not fired");
-}
-END_TEST
-
-START_TEST(test_alloc_large_group)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc ("
-        "a1|a2|a3|a4|a5|a6|a7|a8|"
-        "b1|b2|b3|b4|b5|b6|b7|b8|"
-        "c1|c2|c3|c4|c5|c6|c7|c8|"
-        "d1|d2|d3|d4|d5|d6|d7|d8|"
-        "e1"
-        ")+>\n"
-        "]>\n"
-        "<doc>\n"
-        "<a1/>\n"
-        "</doc>\n";
-    int i;
-    const int max_alloc_count = 50;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler flag not raised");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_group_choice)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "<!ELEMENT doc ("
-        "a1|a2|a3|a4|a5|a6|a7|a8|"
-        "b1|b2|b3|b4|b5|b6|b7|b8|"
-        "c1|c2|c3|c4|c5|c6|c7|c8|"
-        "d1|d2|d3|d4|d5|d6|d7|d8|"
-        "e1"
-        ")+>\n"
-        "]>\n"
-        "<doc>\n"
-        "<a1/>\n"
-        "<b2 attr='foo'>This is a foo</b2>\n"
-        "<c3></c3>\n"
-        "</doc>\n";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetElementDeclHandler(parser, dummy_element_decl_handler);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-    if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
-        fail("Element handler flag not raised");
-}
-END_TEST
-
-START_TEST(test_alloc_pi_in_epilog)
-{
-    const char *text =
-        "<doc></doc>\n"
-        "<?pi in epilog?>";
-    int i;
-    const int max_alloc_count = 15;
+  CharData storage;
+  int i;
+  const int max_realloc_count = 10;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetProcessingInstructionHandler(parser, dummy_pi_handler);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse completed despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != DUMMY_PI_HANDLER_FLAG)
-        fail("Processing instruction handler not invoked");
-}
-END_TEST
-
-START_TEST(test_alloc_comment_in_epilog)
-{
-    const char *text =
-        "<doc></doc>\n"
-        "<!-- comment in epilog -->";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetCommentHandler(parser, dummy_comment_handler);
-        dummy_handler_flags = 0;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse completed despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-    if (dummy_handler_flags != DUMMY_COMMENT_HANDLER_FLAG)
-        fail("Processing instruction handler not invoked");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_long_attribute_value)
-{
-    const char *text =
-        "<!DOCTYPE doc [<!ENTITY foo '"
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    CharData_Init(&storage);
+    XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+    XML_SetStartElementHandler(g_parser, record_element_start_handler);
+    XML_SetUserData(g_parser, &storage);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+  CharData_CheckXMLChars(&storage, XCS("doce"));
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler not fired");
+}
+END_TEST
+
+START_TEST(test_alloc_large_group) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ELEMENT doc ("
+                     "a1|a2|a3|a4|a5|a6|a7|a8|"
+                     "b1|b2|b3|b4|b5|b6|b7|b8|"
+                     "c1|c2|c3|c4|c5|c6|c7|c8|"
+                     "d1|d2|d3|d4|d5|d6|d7|d8|"
+                     "e1"
+                     ")+>\n"
+                     "]>\n"
+                     "<doc>\n"
+                     "<a1/>\n"
+                     "</doc>\n";
+  int i;
+  const int max_alloc_count = 50;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler flag not raised");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_group_choice) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "<!ELEMENT doc ("
+                     "a1|a2|a3|a4|a5|a6|a7|a8|"
+                     "b1|b2|b3|b4|b5|b6|b7|b8|"
+                     "c1|c2|c3|c4|c5|c6|c7|c8|"
+                     "d1|d2|d3|d4|d5|d6|d7|d8|"
+                     "e1"
+                     ")+>\n"
+                     "]>\n"
+                     "<doc>\n"
+                     "<a1/>\n"
+                     "<b2 attr='foo'>This is a foo</b2>\n"
+                     "<c3></c3>\n"
+                     "</doc>\n";
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetElementDeclHandler(g_parser, dummy_element_decl_handler);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+  if (dummy_handler_flags != DUMMY_ELEMENT_DECL_HANDLER_FLAG)
+    fail("Element handler flag not raised");
+}
+END_TEST
+
+START_TEST(test_alloc_pi_in_epilog) {
+  const char *text = "<doc></doc>\n"
+                     "<?pi in epilog?>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetProcessingInstructionHandler(g_parser, dummy_pi_handler);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse completed despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags != DUMMY_PI_HANDLER_FLAG)
+    fail("Processing instruction handler not invoked");
+}
+END_TEST
+
+START_TEST(test_alloc_comment_in_epilog) {
+  const char *text = "<doc></doc>\n"
+                     "<!-- comment in epilog -->";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetCommentHandler(g_parser, dummy_comment_handler);
+    dummy_handler_flags = 0;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse completed despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+  if (dummy_handler_flags != DUMMY_COMMENT_HANDLER_FLAG)
+    fail("Processing instruction handler not invoked");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_long_attribute_value) {
+  const char *text
+      = "<!DOCTYPE doc [<!ENTITY foo '"
         /* Each line is 64 characters */
         "This entity will be substituted as an attribute value, and is   "
         "calculated to be exactly long enough that the terminating NUL   "
@@ -9887,66 +9186,64 @@ START_TEST(test_alloc_realloc_long_attribute_value)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "'>]>\n"
         "<doc a='&foo;'></doc>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_attribute_whitespace)
-{
-    const char *text = "<doc a=' '></doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_attribute_predefined_entity)
-{
-    const char *text = "<doc a='&amp;'></doc>";
-    int i;
-    const int max_alloc_count = 15;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_attribute_whitespace) {
+  const char *text = "<doc a=' '></doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_attribute_predefined_entity) {
+  const char *text = "<doc a='&amp;'></doc>";
+  int i;
+  const int max_alloc_count = 15;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
@@ -9954,10 +9251,9 @@ END_TEST
  * default value for an attribute can trigger pool growth, and recovers
  * if the allocator fails on it.
  */
-START_TEST(test_alloc_long_attr_default_with_char_ref)
-{
-    const char *text =
-        "<!DOCTYPE doc [<!ATTLIST doc a CDATA '"
+START_TEST(test_alloc_long_attr_default_with_char_ref) {
+  const char *text
+      = "<!DOCTYPE doc [<!ATTLIST doc a CDATA '"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -9977,32 +9273,31 @@ START_TEST(test_alloc_long_attr_default_with_char_ref)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHI"
         "&#x31;'>]>\n"
         "<doc/>";
-    int i;
-    const int max_alloc_count = 20;
+  int i;
+  const int max_alloc_count = 20;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
 /* Test that a long character reference substitution triggers a pool
  * expansion correctly for an attribute value.
  */
-START_TEST(test_alloc_long_attr_value)
-{
-    const char *text =
-        "<!DOCTYPE test [<!ENTITY foo '\n"
+START_TEST(test_alloc_long_attr_value) {
+  const char *text
+      = "<!DOCTYPE test [<!ENTITY foo '\n"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -10022,22 +9317,22 @@ START_TEST(test_alloc_long_attr_value)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "'>]>\n"
         "<test a='&foo;'/>";
-    int i;
-    const int max_alloc_count = 25;
+  int i;
+  const int max_alloc_count = 25;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing allocator");
-    if (i == max_alloc_count)
-        fail("Parse failed at maximum allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing allocator");
+  if (i == max_alloc_count)
+    fail("Parse failed at maximum allocation count");
 }
 END_TEST
 
@@ -10046,55 +9341,48 @@ END_TEST
  * exercised can be reached purely by carefully crafted XML, but an
  * allocation error in the right place will definitely do it.
  */
-START_TEST(test_alloc_nested_entities)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
-        "<doc />";
-    ExtFaults test_data = {
-        "<!ENTITY % pe1 '"
-        /* 64 characters per line */
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
-        "'>\n"
-        "<!ENTITY % pe2 '%pe1;'>\n"
-        "%pe2;",
-        "Memory Fail not faulted",
-        NULL,
-        XML_ERROR_NO_MEMORY
-    };
-
-    /* Causes an allocation error in a nested storeEntityValue() */
-    allocation_count = 12;
-    XML_SetUserData(parser, &test_data);
-    XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-    XML_SetExternalEntityRefHandler(parser, external_entity_faulter);
-    expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
-                   "Entity allocation failure not noted");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_param_entity_newline)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc/>";
-    char dtd_text[] =
-        "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
+START_TEST(test_alloc_nested_entities) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/one.ent'>\n"
+                     "<doc />";
+  ExtFaults test_data
+      = {"<!ENTITY % pe1 '"
+         /* 64 characters per line */
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
+         "'>\n"
+         "<!ENTITY % pe2 '%pe1;'>\n"
+         "%pe2;",
+         "Memory Fail not faulted", NULL, XML_ERROR_NO_MEMORY};
+
+  /* Causes an allocation error in a nested storeEntityValue() */
+  allocation_count = 12;
+  XML_SetUserData(g_parser, &test_data);
+  XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+  XML_SetExternalEntityRefHandler(g_parser, external_entity_faulter);
+  expect_failure(text, XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+                 "Entity allocation failure not noted");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_param_entity_newline) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc/>";
+  char dtd_text[]
+      = "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
         /* 64 characters per line */
         "This default value is carefully crafted so that the carriage    "
         "return right at the end of the entity string causes an internal "
@@ -10114,35 +9402,33 @@ START_TEST(test_alloc_realloc_param_entity_newline)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDE"
         "\">\n'>"
         "%pe;\n";
-    int i;
-    const int max_realloc_count = 5;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_ce_extends_pe)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
-        "<doc/>";
-    char dtd_text[] =
-        "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
+  int i;
+  const int max_realloc_count = 5;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_ce_extends_pe) {
+  const char *text = "<!DOCTYPE doc SYSTEM 'http://example.org/'>\n"
+                     "<doc/>";
+  char dtd_text[]
+      = "<!ENTITY % pe '<!ATTLIST doc att CDATA \""
         /* 64 characters per line */
         "This default value is carefully crafted so that the character   "
         "entity at the end causes an internal string pool to have to     "
@@ -10162,115 +9448,111 @@ START_TEST(test_alloc_realloc_ce_extends_pe)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFG&#x51;"
         "\">\n'>"
         "%pe;\n";
-    int i;
-    const int max_realloc_count = 5;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, dtd_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_realloc_attributes)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ATTLIST doc\n"
-        "    a1  (a|b|c)   'a'\n"
-        "    a2  (foo|bar) #IMPLIED\n"
-        "    a3  NMTOKEN   #IMPLIED\n"
-        "    a4  NMTOKENS  #IMPLIED\n"
-        "    a5  ID        #IMPLIED\n"
-        "    a6  IDREF     #IMPLIED\n"
-        "    a7  IDREFS    #IMPLIED\n"
-        "    a8  ENTITY    #IMPLIED\n"
-        "    a9  ENTITIES  #IMPLIED\n"
-        "    a10 CDATA     #IMPLIED\n"
-        "  >]>\n"
-        "<doc>wombat</doc>\n";
-    int i;
-    const int max_realloc_count = 5;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-
-    if (i == 0)
-        fail("Parse succeeded despite failing reallocator");
-    if (i == max_realloc_count)
-        fail("Parse failed at maximum reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_long_doc_name)
-{
-    const char *text =
-        /* 64 characters per line */
-        "<LongRootElementNameThatWillCauseTheNextAllocationToExpandTheStr"
-        "ingPoolForTheDTDQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
-        " a='1'/>";
-    int i;
-    const int max_alloc_count = 20;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max reallocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_long_base)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
-        "  <!ENTITY e SYSTEM 'foo'>\n"
-        "]>\n"
-        "<doc>&e;</doc>";
-    char entity_text[] = "Hello world";
-    const XML_Char *base =
-        /* 64 characters per line */
+  int i;
+  const int max_realloc_count = 5;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, dtd_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_realloc_attributes) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ATTLIST doc\n"
+                     "    a1  (a|b|c)   'a'\n"
+                     "    a2  (foo|bar) #IMPLIED\n"
+                     "    a3  NMTOKEN   #IMPLIED\n"
+                     "    a4  NMTOKENS  #IMPLIED\n"
+                     "    a5  ID        #IMPLIED\n"
+                     "    a6  IDREF     #IMPLIED\n"
+                     "    a7  IDREFS    #IMPLIED\n"
+                     "    a8  ENTITY    #IMPLIED\n"
+                     "    a9  ENTITIES  #IMPLIED\n"
+                     "    a10 CDATA     #IMPLIED\n"
+                     "  >]>\n"
+                     "<doc>wombat</doc>\n";
+  int i;
+  const int max_realloc_count = 5;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+
+  if (i == 0)
+    fail("Parse succeeded despite failing reallocator");
+  if (i == max_realloc_count)
+    fail("Parse failed at maximum reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_long_doc_name) {
+  const char *text =
+      /* 64 characters per line */
+      "<LongRootElementNameThatWillCauseTheNextAllocationToExpandTheStr"
+      "ingPoolForTheDTDQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
+      " a='1'/>";
+  int i;
+  const int max_alloc_count = 20;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max reallocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_long_base) {
+  const char *text = "<!DOCTYPE doc [\n"
+                     "  <!ENTITY e SYSTEM 'foo'>\n"
+                     "]>\n"
+                     "<doc>&e;</doc>";
+  char entity_text[] = "Hello world";
+  const XML_Char *base =
+      /* 64 characters per line */
+      /* clang-format off */
         XCS("LongBaseURI/that/will/overflow/an/internal/buffer/and/cause/it/t")
         XCS("o/have/to/grow/PQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
@@ -10287,36 +9569,36 @@ START_TEST(test_alloc_long_base)
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/");
-    int i;
-    const int max_alloc_count = 25;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, entity_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (XML_SetBase(parser, base) == XML_STATUS_ERROR) {
-            XML_ParserReset(parser, NULL);
-            continue;
-        }
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_long_public_id)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  /* clang-format on */
+  int i;
+  const int max_alloc_count = 25;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, entity_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (XML_SetBase(g_parser, base) == XML_STATUS_ERROR) {
+      XML_ParserReset(g_parser, NULL);
+      continue;
+    }
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_long_public_id) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ENTITY e PUBLIC '"
         /* 64 characters per line */
         "LongPublicIDThatShouldResultInAnInternalStringPoolGrowingAtASpec"
@@ -10338,33 +9620,32 @@ START_TEST(test_alloc_long_public_id)
         "' 'bar'>\n"
         "]>\n"
         "<doc>&e;</doc>";
-    char entity_text[] = "Hello world";
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, entity_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_long_entity_value)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  char entity_text[] = "Hello world";
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, entity_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_long_entity_value) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ENTITY e1 '"
         /* 64 characters per line */
         "Long entity value that should provoke a string pool to grow whil"
@@ -10387,33 +9668,32 @@ START_TEST(test_alloc_long_entity_value)
         "  <!ENTITY e2 SYSTEM 'bar'>\n"
         "]>\n"
         "<doc>&e2;</doc>";
-    char entity_text[] = "Hello world";
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, entity_text);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_alloc);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
-}
-END_TEST
-
-START_TEST(test_alloc_long_notation)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  char entity_text[] = "Hello world";
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, entity_text);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_alloc);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
+}
+END_TEST
+
+START_TEST(test_alloc_long_notation) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!NOTATION note SYSTEM '"
         /* 64 characters per line */
         "ALongNotationNameThatShouldProvokeStringPoolGrowthWhileCallingAn"
@@ -10455,156 +9735,144 @@ START_TEST(test_alloc_long_notation)
         "  <!ENTITY e2 SYSTEM 'bar'>\n"
         "]>\n"
         "<doc>&e2;</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "Entity Foo" },
-        { XCS("bar"), "Entity Bar" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-
-        /* See comment in test_alloc_parse_xdecl() */
-        alloc_teardown();
-        alloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  ExtOption options[]
+      = {{XCS("foo"), "Entity Foo"}, {XCS("bar"), "Entity Bar"}, {NULL, NULL}};
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+
+    /* See comment in test_alloc_parse_xdecl() */
+    alloc_teardown();
+    alloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
-
 static void
-nsalloc_setup(void)
-{
-    XML_Memory_Handling_Suite memsuite = {
-        duff_allocator,
-        duff_reallocator,
-        free
-    };
-    XML_Char ns_sep[2] = { ' ', '\0' };
-
-    /* Ensure the parser creation will go through */
-    allocation_count = ALLOC_ALWAYS_SUCCEED;
-    reallocation_count = REALLOC_ALWAYS_SUCCEED;
-    parser = XML_ParserCreate_MM(NULL, &memsuite, ns_sep);
-    if (parser == NULL)
-        fail("Parser not created");
+nsalloc_setup(void) {
+  XML_Memory_Handling_Suite memsuite = {duff_allocator, duff_reallocator, free};
+  XML_Char ns_sep[2] = {' ', '\0'};
+
+  /* Ensure the parser creation will go through */
+  allocation_count = ALLOC_ALWAYS_SUCCEED;
+  reallocation_count = REALLOC_ALWAYS_SUCCEED;
+  g_parser = XML_ParserCreate_MM(NULL, &memsuite, ns_sep);
+  if (g_parser == NULL)
+    fail("Parser not created");
 }
 
 static void
-nsalloc_teardown(void)
-{
-    basic_teardown();
+nsalloc_teardown(void) {
+  basic_teardown();
 }
 
-
 /* Test the effects of allocation failure in simple namespace parsing.
  * Based on test_ns_default_with_empty_uri()
  */
-START_TEST(test_nsalloc_xmlns)
-{
-    const char *text =
-        "<doc xmlns='http://example.org/'>\n"
-        "  <e xmlns=''/>\n"
-        "</doc>";
-    unsigned int i;
-    const unsigned int max_alloc_count = 30;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        /* Exercise more code paths with a default handler */
-        XML_SetDefaultHandler(parser, dummy_default_handler);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* Resetting the parser is insufficient, because some memory
-         * allocations are cached within the parser.  Instead we use
-         * the teardown and setup routines to ensure that we have the
-         * right sort of parser back in our hands.
-         */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at maximum allocation count");
+START_TEST(test_nsalloc_xmlns) {
+  const char *text = "<doc xmlns='http://example.org/'>\n"
+                     "  <e xmlns=''/>\n"
+                     "</doc>";
+  unsigned int i;
+  const unsigned int max_alloc_count = 30;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    /* Exercise more code paths with a default handler */
+    XML_SetDefaultHandler(g_parser, dummy_default_handler);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* Resetting the parser is insufficient, because some memory
+     * allocations are cached within the parser.  Instead we use
+     * the teardown and setup routines to ensure that we have the
+     * right sort of parser back in our hands.
+     */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at maximum allocation count");
 }
 END_TEST
 
 /* Test XML_ParseBuffer interface with namespace and a dicky allocator */
-START_TEST(test_nsalloc_parse_buffer)
-{
-    const char *text = "<doc>Hello</doc>";
-    void *buffer;
-
-    /* Try a parse before the start of the world */
-    /* (Exercises new code path) */
-    allocation_count = 0;
-    if (XML_ParseBuffer(parser, 0, XML_FALSE) != XML_STATUS_ERROR)
-        fail("Pre-init XML_ParseBuffer not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_NO_MEMORY)
-        fail("Pre-init XML_ParseBuffer faulted for wrong reason");
-
-    /* Now with actual memory allocation */
-    allocation_count = ALLOC_ALWAYS_SUCCEED;
-    if (XML_ParseBuffer(parser, 0, XML_FALSE) != XML_STATUS_OK)
-        xml_failure(parser);
-
-    /* Check that resuming an unsuspended parser is faulted */
-    if (XML_ResumeParser(parser) != XML_STATUS_ERROR)
-        fail("Resuming unsuspended parser not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_NOT_SUSPENDED)
-        xml_failure(parser);
-
-    /* Get the parser into suspended state */
-    XML_SetCharacterDataHandler(parser, clearing_aborting_character_handler);
-    resumable = XML_TRUE;
-    buffer = XML_GetBuffer(parser, (int)strlen(text));
-    if (buffer == NULL)
-        fail("Could not acquire parse buffer");
-    memcpy(buffer, text, strlen(text));
-    if (XML_ParseBuffer(parser, (int)strlen(text),
-                        XML_TRUE) != XML_STATUS_SUSPENDED)
-        xml_failure(parser);
-    if (XML_GetErrorCode(parser) != XML_ERROR_NONE)
-        xml_failure(parser);
-    if (XML_ParseBuffer(parser, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Suspended XML_ParseBuffer not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_SUSPENDED)
-        xml_failure(parser);
-    if (XML_GetBuffer(parser, (int)strlen(text)) != NULL)
-        fail("Suspended XML_GetBuffer not faulted");
-
-    /* Get it going again and complete the world */
-    XML_SetCharacterDataHandler(parser, NULL);
-    if (XML_ResumeParser(parser) != XML_STATUS_OK)
-        xml_failure(parser);
-    if (XML_ParseBuffer(parser, (int)strlen(text), XML_TRUE) != XML_STATUS_ERROR)
-        fail("Post-finishing XML_ParseBuffer not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_FINISHED)
-        xml_failure(parser);
-    if (XML_GetBuffer(parser, (int)strlen(text)) != NULL)
-        fail("Post-finishing XML_GetBuffer not faulted");
+START_TEST(test_nsalloc_parse_buffer) {
+  const char *text = "<doc>Hello</doc>";
+  void *buffer;
+
+  /* Try a parse before the start of the world */
+  /* (Exercises new code path) */
+  allocation_count = 0;
+  if (XML_ParseBuffer(g_parser, 0, XML_FALSE) != XML_STATUS_ERROR)
+    fail("Pre-init XML_ParseBuffer not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NO_MEMORY)
+    fail("Pre-init XML_ParseBuffer faulted for wrong reason");
+
+  /* Now with actual memory allocation */
+  allocation_count = ALLOC_ALWAYS_SUCCEED;
+  if (XML_ParseBuffer(g_parser, 0, XML_FALSE) != XML_STATUS_OK)
+    xml_failure(g_parser);
+
+  /* Check that resuming an unsuspended parser is faulted */
+  if (XML_ResumeParser(g_parser) != XML_STATUS_ERROR)
+    fail("Resuming unsuspended parser not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NOT_SUSPENDED)
+    xml_failure(g_parser);
+
+  /* Get the parser into suspended state */
+  XML_SetCharacterDataHandler(g_parser, clearing_aborting_character_handler);
+  resumable = XML_TRUE;
+  buffer = XML_GetBuffer(g_parser, (int)strlen(text));
+  if (buffer == NULL)
+    fail("Could not acquire parse buffer");
+  assert(buffer != NULL);
+  memcpy(buffer, text, strlen(text));
+  if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_SUSPENDED)
+    xml_failure(g_parser);
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_NONE)
+    xml_failure(g_parser);
+  if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Suspended XML_ParseBuffer not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_SUSPENDED)
+    xml_failure(g_parser);
+  if (XML_GetBuffer(g_parser, (int)strlen(text)) != NULL)
+    fail("Suspended XML_GetBuffer not faulted");
+
+  /* Get it going again and complete the world */
+  XML_SetCharacterDataHandler(g_parser, NULL);
+  if (XML_ResumeParser(g_parser) != XML_STATUS_OK)
+    xml_failure(g_parser);
+  if (XML_ParseBuffer(g_parser, (int)strlen(text), XML_TRUE)
+      != XML_STATUS_ERROR)
+    fail("Post-finishing XML_ParseBuffer not faulted");
+  if (XML_GetErrorCode(g_parser) != XML_ERROR_FINISHED)
+    xml_failure(g_parser);
+  if (XML_GetBuffer(g_parser, (int)strlen(text)) != NULL)
+    fail("Post-finishing XML_GetBuffer not faulted");
 }
 END_TEST
 
 /* Check handling of long prefix names (pool growth) */
-START_TEST(test_nsalloc_long_prefix)
-{
-    const char *text =
-        "<"
+START_TEST(test_nsalloc_long_prefix) {
+  const char *text
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -10658,30 +9926,29 @@ START_TEST(test_nsalloc_long_prefix)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":foo>";
-    int i;
-    const int max_alloc_count = 40;
+  int i;
+  const int max_alloc_count = 40;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Check handling of long uri names (pool growth) */
-START_TEST(test_nsalloc_long_uri)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/"
+START_TEST(test_nsalloc_long_uri) {
+  const char *text
+      = "<foo:e xmlns:foo='http://example.org/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
@@ -10719,30 +9986,29 @@ START_TEST(test_nsalloc_long_uri)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "'>"
         "</foo:e>";
-    int i;
-    const int max_alloc_count = 40;
+  int i;
+  const int max_alloc_count = 40;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Test handling of long attribute names with prefixes */
-START_TEST(test_nsalloc_long_attr)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' bar:"
+START_TEST(test_nsalloc_long_attr) {
+  const char *text
+      = "<foo:e xmlns:foo='http://example.org/' bar:"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -10763,30 +10029,29 @@ START_TEST(test_nsalloc_long_attr)
         "='12'\n"
         "xmlns:bar='http://example.org/'>"
         "</foo:e>";
-    int i;
-    const int max_alloc_count = 40;
+  int i;
+  const int max_alloc_count = 40;
 
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Test handling of an attribute name with a long namespace prefix */
-START_TEST(test_nsalloc_long_attr_prefix)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' "
+START_TEST(test_nsalloc_long_attr_prefix) {
+  const char *text
+      = "<foo:e xmlns:foo='http://example.org/' "
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -10825,7 +10090,8 @@ START_TEST(test_nsalloc_long_attr_prefix)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='http://example.org/'>"
         "</foo:e>";
-    const XML_Char *elemstr[] = {
+  const XML_Char *elemstr[] = {
+      /* clang-format off */
         XCS("http://example.org/ e foo"),
         XCS("http://example.org/ a ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
@@ -10844,91 +10110,84 @@ START_TEST(test_nsalloc_long_attr_prefix)
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
-    };
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetReturnNSTriplet(parser, XML_TRUE);
-        XML_SetUserData(parser, (void *)elemstr);
-        XML_SetElementHandler(parser,
-                              triplet_start_checker,
-                              triplet_end_checker);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+      /* clang-format on */
+  };
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+    XML_SetUserData(g_parser, (void *)elemstr);
+    XML_SetElementHandler(g_parser, triplet_start_checker, triplet_end_checker);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Test attribute handling in the face of a dodgy reallocator */
-START_TEST(test_nsalloc_realloc_attributes)
-{
-    const char *text =
-        "<foo:e xmlns:foo='http://example.org/' bar:a='12'\n"
-        "       xmlns:bar='http://example.org/'>"
-        "</foo:e>";
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed at max reallocation count");
+START_TEST(test_nsalloc_realloc_attributes) {
+  const char *text = "<foo:e xmlns:foo='http://example.org/' bar:a='12'\n"
+                     "       xmlns:bar='http://example.org/'>"
+                     "</foo:e>";
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed at max reallocation count");
 }
 END_TEST
 
 /* Test long element names with namespaces under a failing allocator */
-START_TEST(test_nsalloc_long_element)
-{
-    const char *text =
-        "<foo:thisisalongenoughelementnametotriggerareallocation\n"
+START_TEST(test_nsalloc_long_element) {
+  const char *text
+      = "<foo:thisisalongenoughelementnametotriggerareallocation\n"
         " xmlns:foo='http://example.org/' bar:a='12'\n"
         " xmlns:bar='http://example.org/'>"
         "</foo:thisisalongenoughelementnametotriggerareallocation>";
-    const XML_Char *elemstr[] = {
-        XCS("http://example.org/")
-        XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
-        XCS("http://example.org/ a bar")
-    };
-    int i;
-    const int max_alloc_count = 30;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetReturnNSTriplet(parser, XML_TRUE);
-        XML_SetUserData(parser, (void *)elemstr);
-        XML_SetElementHandler(parser,
-                              triplet_start_checker,
-                              triplet_end_checker);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed at max reallocation count");
+  const XML_Char *elemstr[]
+      = {XCS("http://example.org/")
+             XCS(" thisisalongenoughelementnametotriggerareallocation foo"),
+         XCS("http://example.org/ a bar")};
+  int i;
+  const int max_alloc_count = 30;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetReturnNSTriplet(g_parser, XML_TRUE);
+    XML_SetUserData(g_parser, (void *)elemstr);
+    XML_SetElementHandler(g_parser, triplet_start_checker, triplet_end_checker);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed at max reallocation count");
 }
 END_TEST
 
@@ -10942,44 +10201,41 @@ END_TEST
  * new binding has a longer URI, it will need reallocation.  This test
  * provokes that reallocation, and tests the control path if it fails.
  */
-START_TEST(test_nsalloc_realloc_binding_uri)
-{
-    const char *first =
-        "<doc xmlns='http://example.org/'>\n"
-        "  <e xmlns='' />\n"
-        "</doc>";
-    const char *second =
-        "<doc xmlns='http://example.org/long/enough/URI/to/reallocate/'>\n"
+START_TEST(test_nsalloc_realloc_binding_uri) {
+  const char *first = "<doc xmlns='http://example.org/'>\n"
+                      "  <e xmlns='' />\n"
+                      "</doc>";
+  const char *second
+      = "<doc xmlns='http://example.org/long/enough/URI/to/reallocate/'>\n"
         "  <e xmlns='' />\n"
         "</doc>";
-    unsigned i;
-    const unsigned max_realloc_count = 10;
-
-    /* First, do a full parse that will leave bindings around */
-    if (_XML_Parse_SINGLE_BYTES(parser, first, (int)strlen(first),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
-
-    /* Now repeat with a longer URI and a duff reallocator */
-    for (i = 0; i < max_realloc_count; i++) {
-        XML_ParserReset(parser, NULL);
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, second, (int)strlen(second),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocation");
-    else if (i == max_realloc_count)
-        fail("Parsing failed at max reallocation count");
+  unsigned i;
+  const unsigned max_realloc_count = 10;
+
+  /* First, do a full parse that will leave bindings around */
+  if (_XML_Parse_SINGLE_BYTES(g_parser, first, (int)strlen(first), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+
+  /* Now repeat with a longer URI and a duff reallocator */
+  for (i = 0; i < max_realloc_count; i++) {
+    XML_ParserReset(g_parser, NULL);
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, second, (int)strlen(second), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocation");
+  else if (i == max_realloc_count)
+    fail("Parsing failed at max reallocation count");
 }
 END_TEST
 
 /* Check handling of long prefix names (pool growth) */
-START_TEST(test_nsalloc_realloc_long_prefix)
-{
-    const char *text =
-        "<"
+START_TEST(test_nsalloc_realloc_long_prefix) {
+  const char *text
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -11033,30 +10289,29 @@ START_TEST(test_nsalloc_realloc_long_prefix)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":foo>";
-    int i;
-    const int max_realloc_count = 12;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed even at max reallocation count");
+  int i;
+  const int max_realloc_count = 12;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed even at max reallocation count");
 }
 END_TEST
 
 /* Check handling of even long prefix names (different code path) */
-START_TEST(test_nsalloc_realloc_longer_prefix)
-{
-    const char *text =
-        "<"
+START_TEST(test_nsalloc_realloc_longer_prefix) {
+  const char *text
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -11110,29 +10365,28 @@ START_TEST(test_nsalloc_realloc_longer_prefix)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "Q:foo>";
-    int i;
-    const int max_realloc_count = 12;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed even at max reallocation count");
-}
-END_TEST
-
-START_TEST(test_nsalloc_long_namespace)
-{
-    const char *text1 =
-        "<"
+  int i;
+  const int max_realloc_count = 12;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed even at max reallocation count");
+}
+END_TEST
+
+START_TEST(test_nsalloc_long_namespace) {
+  const char *text1
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -11168,8 +10422,8 @@ START_TEST(test_nsalloc_long_namespace)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='http://example.org/'>\n";
-    const char *text2 =
-        "<"
+  const char *text2
+      = "<"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -11222,34 +10476,34 @@ START_TEST(test_nsalloc_long_namespace)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":e>";
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                    XML_FALSE) != XML_STATUS_ERROR &&
-            _XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+            != XML_STATUS_ERROR
+        && _XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2),
+                                   XML_TRUE)
+               != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Using a slightly shorter namespace name provokes allocations in
  * slightly different places in the code.
  */
-START_TEST(test_nsalloc_less_long_namespace)
-{
-    const char *text =
-        "<"
+START_TEST(test_nsalloc_less_long_namespace) {
+  const char *text
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
@@ -11298,29 +10552,28 @@ START_TEST(test_nsalloc_less_long_namespace)
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         ":e>";
-    int i;
-    const int max_alloc_count = 40;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
-}
-END_TEST
-
-START_TEST(test_nsalloc_long_context)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+  int i;
+  const int max_alloc_count = 40;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
+}
+END_TEST
+
+START_TEST(test_nsalloc_long_context) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ATTLIST doc baz ID #REQUIRED>\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
@@ -11345,31 +10598,28 @@ START_TEST(test_nsalloc_long_context)
         "' baz='2'>\n"
         "&en;"
         "</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT e EMPTY>"},
-        { XCS("bar"), "<e/>" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 70;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+  ExtOption options[] = {
+      {XCS("foo"), "<!ELEMENT e EMPTY>"}, {XCS("bar"), "<e/>"}, {NULL, NULL}};
+  int i;
+  const int max_alloc_count = 70;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
@@ -11377,38 +10627,33 @@ END_TEST
  * returns normally it must have succeeded.
  */
 static void
-context_realloc_test(const char *text)
-{
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT e EMPTY>"},
-        { XCS("bar"), "<e/>" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_realloc_count = 6;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed even at max reallocation count");
-}
-
-START_TEST(test_nsalloc_realloc_long_context)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+context_realloc_test(const char *text) {
+  ExtOption options[] = {
+      {XCS("foo"), "<!ELEMENT e EMPTY>"}, {XCS("bar"), "<e/>"}, {NULL, NULL}};
+  int i;
+  const int max_realloc_count = 6;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed even at max reallocation count");
+}
+
+START_TEST(test_nsalloc_realloc_long_context) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11433,14 +10678,13 @@ START_TEST(test_nsalloc_realloc_long_context)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_2)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_2) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11465,14 +10709,13 @@ START_TEST(test_nsalloc_realloc_long_context_2)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_3)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_3) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11497,14 +10740,13 @@ START_TEST(test_nsalloc_realloc_long_context_3)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_4)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_4) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11529,14 +10771,13 @@ START_TEST(test_nsalloc_realloc_long_context_4)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_5)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_5) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11561,14 +10802,13 @@ START_TEST(test_nsalloc_realloc_long_context_5)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_6)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_6) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11592,14 +10832,13 @@ START_TEST(test_nsalloc_realloc_long_context_6)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_context_7)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_context_7) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/"
@@ -11624,14 +10863,13 @@ START_TEST(test_nsalloc_realloc_long_context_7)
         "&en;"
         "</doc>";
 
-    context_realloc_test(text);
+  context_realloc_test(text);
 }
 END_TEST
 
-START_TEST(test_nsalloc_realloc_long_ge_name)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+START_TEST(test_nsalloc_realloc_long_ge_name) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY "
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -11673,30 +10911,27 @@ START_TEST(test_nsalloc_realloc_long_ge_name)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ";"
         "</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT el EMPTY>" },
-        { XCS("bar"), "<el/>" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_realloc_count = 10;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed even at max reallocation count");
+  ExtOption options[] = {
+      {XCS("foo"), "<!ELEMENT el EMPTY>"}, {XCS("bar"), "<el/>"}, {NULL, NULL}};
+  int i;
+  const int max_realloc_count = 10;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed even at max reallocation count");
 }
 END_TEST
 
@@ -11705,10 +10940,9 @@ END_TEST
  * failures correctly.  The prefix is exactly the right length to
  * provoke particular uncommon code paths.
  */
-START_TEST(test_nsalloc_realloc_long_context_in_dtd)
-{
-    const char *text1 =
-        "<!DOCTYPE "
+START_TEST(test_nsalloc_realloc_long_context_in_dtd) {
+  const char *text1
+      = "<!DOCTYPE "
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -11764,7 +10998,8 @@ START_TEST(test_nsalloc_realloc_long_context_in_dtd)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "='foo/Second'>&First;";
-    const char *text2 = "</"
+  const char *text2
+      = "</"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -11782,38 +11017,35 @@ START_TEST(test_nsalloc_realloc_long_context_in_dtd)
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":doc>";
-    ExtOption options[] = {
-        { XCS("foo/First"), "Hello world" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_realloc_count = 20;
-
-    for (i = 0; i < max_realloc_count; i++) {
-        reallocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text1, (int)strlen(text1),
-                                    XML_FALSE) != XML_STATUS_ERROR &&
-            _XML_Parse_SINGLE_BYTES(parser, text2, (int)strlen(text2),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing reallocations");
-    else if (i == max_realloc_count)
-        fail("Parsing failed even at max reallocation count");
-}
-END_TEST
-
-START_TEST(test_nsalloc_long_default_in_ext)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+  ExtOption options[] = {{XCS("foo/First"), "Hello world"}, {NULL, NULL}};
+  int i;
+  const int max_realloc_count = 20;
+
+  for (i = 0; i < max_realloc_count; i++) {
+    reallocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text1, (int)strlen(text1), XML_FALSE)
+            != XML_STATUS_ERROR
+        && _XML_Parse_SINGLE_BYTES(g_parser, text2, (int)strlen(text2),
+                                   XML_TRUE)
+               != XML_STATUS_ERROR)
+      break;
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing reallocations");
+  else if (i == max_realloc_count)
+    fail("Parsing failed even at max reallocation count");
+}
+END_TEST
+
+START_TEST(test_nsalloc_long_default_in_ext) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ATTLIST e a1 CDATA '"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
@@ -11836,37 +11068,33 @@ START_TEST(test_nsalloc_long_default_in_ext)
         "  <!ENTITY x SYSTEM 'foo'>\n"
         "]>\n"
         "<doc>&x;</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<e/>"},
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 50;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
-}
-END_TEST
-
-START_TEST(test_nsalloc_long_systemid_in_ext)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+  ExtOption options[] = {{XCS("foo"), "<e/>"}, {NULL, NULL}};
+  int i;
+  const int max_alloc_count = 50;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
+}
+END_TEST
+
+START_TEST(test_nsalloc_long_systemid_in_ext) {
+  const char *text
+      = "<!DOCTYPE doc SYSTEM 'foo' [\n"
         "  <!ENTITY en SYSTEM '"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
@@ -11888,9 +11116,9 @@ START_TEST(test_nsalloc_long_systemid_in_ext)
         "'>\n"
         "]>\n"
         "<doc>&en;</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT e EMPTY>" },
-        {
+  ExtOption options[] = {
+      {XCS("foo"), "<!ELEMENT e EMPTY>"},
+      {/* clang-format off */
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
@@ -11907,465 +11135,463 @@ START_TEST(test_nsalloc_long_systemid_in_ext)
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"),
-            "<e/>"
-        },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 55;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+       /* clang-format on */
+       "<e/>"},
+      {NULL, NULL}};
+  int i;
+  const int max_alloc_count = 55;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Parsing worked despite failing allocations");
+  else if (i == max_alloc_count)
+    fail("Parsing failed even at max allocation count");
 }
 END_TEST
 
 /* Test the effects of allocation failure on parsing an element in a
  * namespace.  Based on test_nsalloc_long_context.
  */
-START_TEST(test_nsalloc_prefixed_element)
-{
-    const char *text =
-        "<!DOCTYPE pfx:element SYSTEM 'foo' [\n"
-        "  <!ATTLIST pfx:element baz ID #REQUIRED>\n"
-        "  <!ENTITY en SYSTEM 'bar'>\n"
-        "]>\n"
-        "<pfx:element xmlns:pfx='http://example.org/' baz='2'>\n"
-        "&en;"
-        "</pfx:element>";
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT e EMPTY>" },
-        { XCS("bar"), "<e/>" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 70;
-
-    for (i = 0; i < max_alloc_count; i++) {
-        allocation_count = i;
-        XML_SetUserData(parser, options);
-        XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
-        XML_SetExternalEntityRefHandler(parser, external_entity_optioner);
-        if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text),
-                                    XML_TRUE) != XML_STATUS_ERROR)
-            break;
-
-        /* See comment in test_nsalloc_xmlns() */
-        nsalloc_teardown();
-        nsalloc_setup();
-    }
-    if (i == 0)
-        fail("Success despite failing allocator");
-    else if (i == max_alloc_count)
-        fail("Failed even at full allocation count");
+START_TEST(test_nsalloc_prefixed_element) {
+  const char *text = "<!DOCTYPE pfx:element SYSTEM 'foo' [\n"
+                     "  <!ATTLIST pfx:element baz ID #REQUIRED>\n"
+                     "  <!ENTITY en SYSTEM 'bar'>\n"
+                     "]>\n"
+                     "<pfx:element xmlns:pfx='http://example.org/' baz='2'>\n"
+                     "&en;"
+                     "</pfx:element>";
+  ExtOption options[] = {
+      {XCS("foo"), "<!ELEMENT e EMPTY>"}, {XCS("bar"), "<e/>"}, {NULL, NULL}};
+  int i;
+  const int max_alloc_count = 70;
+
+  for (i = 0; i < max_alloc_count; i++) {
+    allocation_count = i;
+    XML_SetUserData(g_parser, options);
+    XML_SetParamEntityParsing(g_parser, XML_PARAM_ENTITY_PARSING_ALWAYS);
+    XML_SetExternalEntityRefHandler(g_parser, external_entity_optioner);
+    if (_XML_Parse_SINGLE_BYTES(g_parser, text, (int)strlen(text), XML_TRUE)
+        != XML_STATUS_ERROR)
+      break;
+
+    /* See comment in test_nsalloc_xmlns() */
+    nsalloc_teardown();
+    nsalloc_setup();
+  }
+  if (i == 0)
+    fail("Success despite failing allocator");
+  else if (i == max_alloc_count)
+    fail("Failed even at full allocation count");
 }
 END_TEST
 
 static Suite *
-make_suite(void)
-{
-    Suite *s = suite_create("basic");
-    TCase *tc_basic = tcase_create("basic tests");
-    TCase *tc_namespace = tcase_create("XML namespaces");
-    TCase *tc_misc = tcase_create("miscellaneous tests");
-    TCase *tc_alloc = tcase_create("allocation tests");
-    TCase *tc_nsalloc = tcase_create("namespace allocation tests");
-
-    suite_add_tcase(s, tc_basic);
-    tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
-    tcase_add_test(tc_basic, test_nul_byte);
-    tcase_add_test(tc_basic, test_u0000_char);
-    tcase_add_test(tc_basic, test_siphash_self);
-    tcase_add_test(tc_basic, test_siphash_spec);
-    tcase_add_test(tc_basic, test_bom_utf8);
-    tcase_add_test(tc_basic, test_bom_utf16_be);
-    tcase_add_test(tc_basic, test_bom_utf16_le);
-    tcase_add_test(tc_basic, test_nobom_utf16_le);
-    tcase_add_test(tc_basic, test_illegal_utf8);
-    tcase_add_test(tc_basic, test_utf8_auto_align);
-    tcase_add_test(tc_basic, test_utf16);
-    tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
-    tcase_add_test(tc_basic, test_not_utf16);
-    tcase_add_test(tc_basic, test_bad_encoding);
-    tcase_add_test(tc_basic, test_latin1_umlauts);
-    tcase_add_test(tc_basic, test_long_utf8_character);
-    tcase_add_test(tc_basic, test_long_latin1_attribute);
-    tcase_add_test(tc_basic, test_long_ascii_attribute);
-    /* Regression test for SF bug #491986. */
-    tcase_add_test(tc_basic, test_danish_latin1);
-    /* Regression test for SF bug #514281. */
-    tcase_add_test(tc_basic, test_french_charref_hexidecimal);
-    tcase_add_test(tc_basic, test_french_charref_decimal);
-    tcase_add_test(tc_basic, test_french_latin1);
-    tcase_add_test(tc_basic, test_french_utf8);
-    tcase_add_test(tc_basic, test_utf8_false_rejection);
-    tcase_add_test(tc_basic, test_line_number_after_parse);
-    tcase_add_test(tc_basic, test_column_number_after_parse);
-    tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers);
-    tcase_add_test(tc_basic, test_line_number_after_error);
-    tcase_add_test(tc_basic, test_column_number_after_error);
-    tcase_add_test(tc_basic, test_really_long_lines);
-    tcase_add_test(tc_basic, test_really_long_encoded_lines);
-    tcase_add_test(tc_basic, test_end_element_events);
-    tcase_add_test(tc_basic, test_attr_whitespace_normalization);
-    tcase_add_test(tc_basic, test_xmldecl_misplaced);
-    tcase_add_test(tc_basic, test_xmldecl_invalid);
-    tcase_add_test(tc_basic, test_xmldecl_missing_attr);
-    tcase_add_test(tc_basic, test_xmldecl_missing_value);
-    tcase_add_test(tc_basic, test_unknown_encoding_internal_entity);
-    tcase_add_test(tc_basic, test_unrecognised_encoding_internal_entity);
-    tcase_add_test(tc_basic,
-                   test_wfc_undeclared_entity_unread_external_subset);
-    tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
-    tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
-    tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
-    tcase_add_test(tc_basic, test_not_standalone_handler_reject);
-    tcase_add_test(tc_basic, test_not_standalone_handler_accept);
-    tcase_add_test(tc_basic,
-                   test_wfc_undeclared_entity_with_external_subset_standalone);
-    tcase_add_test(tc_basic,
-                   test_entity_with_external_subset_unless_standalone);
-    tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs);
-    tcase_add_test(tc_basic, test_ext_entity_set_encoding);
-    tcase_add_test(tc_basic, test_ext_entity_no_handler);
-    tcase_add_test(tc_basic, test_ext_entity_set_bom);
-    tcase_add_test(tc_basic, test_ext_entity_bad_encoding);
-    tcase_add_test(tc_basic, test_ext_entity_bad_encoding_2);
-    tcase_add_test(tc_basic, test_ext_entity_invalid_parse);
-    tcase_add_test(tc_basic, test_ext_entity_invalid_suspended_parse);
-    tcase_add_test(tc_basic, test_dtd_default_handling);
-    tcase_add_test(tc_basic, test_dtd_attr_handling);
-    tcase_add_test(tc_basic, test_empty_ns_without_namespaces);
-    tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces);
-    tcase_add_test(tc_basic, test_stop_parser_between_char_data_calls);
-    tcase_add_test(tc_basic, test_suspend_parser_between_char_data_calls);
-    tcase_add_test(tc_basic, test_repeated_stop_parser_between_char_data_calls);
-    tcase_add_test(tc_basic, test_good_cdata_ascii);
-    tcase_add_test(tc_basic, test_good_cdata_utf16);
-    tcase_add_test(tc_basic, test_good_cdata_utf16_le);
-    tcase_add_test(tc_basic, test_long_cdata_utf16);
-    tcase_add_test(tc_basic, test_multichar_cdata_utf16);
-    tcase_add_test(tc_basic, test_utf16_bad_surrogate_pair);
-    tcase_add_test(tc_basic, test_bad_cdata);
-    tcase_add_test(tc_basic, test_bad_cdata_utf16);
-    tcase_add_test(tc_basic, test_stop_parser_between_cdata_calls);
-    tcase_add_test(tc_basic, test_suspend_parser_between_cdata_calls);
-    tcase_add_test(tc_basic, test_memory_allocation);
-    tcase_add_test(tc_basic, test_default_current);
-    tcase_add_test(tc_basic, test_dtd_elements);
-    tcase_add_test(tc_basic, test_set_foreign_dtd);
-    tcase_add_test(tc_basic, test_foreign_dtd_not_standalone);
-    tcase_add_test(tc_basic, test_invalid_foreign_dtd);
-    tcase_add_test(tc_basic, test_foreign_dtd_with_doctype);
-    tcase_add_test(tc_basic, test_foreign_dtd_without_external_subset);
-    tcase_add_test(tc_basic, test_empty_foreign_dtd);
-    tcase_add_test(tc_basic, test_set_base);
-    tcase_add_test(tc_basic, test_attributes);
-    tcase_add_test(tc_basic, test_reset_in_entity);
-    tcase_add_test(tc_basic, test_resume_invalid_parse);
-    tcase_add_test(tc_basic, test_resume_resuspended);
-    tcase_add_test(tc_basic, test_cdata_default);
-    tcase_add_test(tc_basic, test_subordinate_reset);
-    tcase_add_test(tc_basic, test_subordinate_suspend);
-    tcase_add_test(tc_basic, test_subordinate_xdecl_suspend);
-    tcase_add_test(tc_basic, test_subordinate_xdecl_abort);
-    tcase_add_test(tc_basic, test_explicit_encoding);
-    tcase_add_test(tc_basic, test_trailing_cr);
-    tcase_add_test(tc_basic, test_ext_entity_trailing_cr);
-    tcase_add_test(tc_basic, test_trailing_rsqb);
-    tcase_add_test(tc_basic, test_ext_entity_trailing_rsqb);
-    tcase_add_test(tc_basic, test_ext_entity_good_cdata);
-    tcase_add_test(tc_basic, test_user_parameters);
-    tcase_add_test(tc_basic, test_ext_entity_ref_parameter);
-    tcase_add_test(tc_basic, test_empty_parse);
-    tcase_add_test(tc_basic, test_get_buffer_1);
-    tcase_add_test(tc_basic, test_get_buffer_2);
-    tcase_add_test(tc_basic, test_byte_info_at_end);
-    tcase_add_test(tc_basic, test_byte_info_at_error);
-    tcase_add_test(tc_basic, test_byte_info_at_cdata);
-    tcase_add_test(tc_basic, test_predefined_entities);
-    tcase_add_test(tc_basic, test_invalid_tag_in_dtd);
-    tcase_add_test(tc_basic, test_not_predefined_entities);
-    tcase_add_test(tc_basic, test_ignore_section);
-    tcase_add_test(tc_basic, test_ignore_section_utf16);
-    tcase_add_test(tc_basic, test_ignore_section_utf16_be);
-    tcase_add_test(tc_basic, test_bad_ignore_section);
-    tcase_add_test(tc_basic, test_external_entity_values);
-    tcase_add_test(tc_basic, test_ext_entity_not_standalone);
-    tcase_add_test(tc_basic, test_ext_entity_value_abort);
-    tcase_add_test(tc_basic, test_bad_public_doctype);
-    tcase_add_test(tc_basic, test_attribute_enum_value);
-    tcase_add_test(tc_basic, test_predefined_entity_redefinition);
-    tcase_add_test(tc_basic, test_dtd_stop_processing);
-    tcase_add_test(tc_basic, test_public_notation_no_sysid);
-    tcase_add_test(tc_basic, test_nested_groups);
-    tcase_add_test(tc_basic, test_group_choice);
-    tcase_add_test(tc_basic, test_standalone_parameter_entity);
-    tcase_add_test(tc_basic, test_skipped_parameter_entity);
-    tcase_add_test(tc_basic, test_recursive_external_parameter_entity);
-    tcase_add_test(tc_basic, test_undefined_ext_entity_in_external_dtd);
-    tcase_add_test(tc_basic, test_suspend_xdecl);
-    tcase_add_test(tc_basic, test_abort_epilog);
-    tcase_add_test(tc_basic, test_abort_epilog_2);
-    tcase_add_test(tc_basic, test_suspend_epilog);
-    tcase_add_test(tc_basic, test_suspend_in_sole_empty_tag);
-    tcase_add_test(tc_basic, test_unfinished_epilog);
-    tcase_add_test(tc_basic, test_partial_char_in_epilog);
-    tcase_add_test(tc_basic, test_hash_collision);
-    tcase_add_test(tc_basic, test_suspend_resume_internal_entity);
-    tcase_add_test(tc_basic, test_resume_entity_with_syntax_error);
-    tcase_add_test(tc_basic, test_suspend_resume_parameter_entity);
-    tcase_add_test(tc_basic, test_restart_on_error);
-    tcase_add_test(tc_basic, test_reject_lt_in_attribute_value);
-    tcase_add_test(tc_basic, test_reject_unfinished_param_in_att_value);
-    tcase_add_test(tc_basic, test_trailing_cr_in_att_value);
-    tcase_add_test(tc_basic, test_standalone_internal_entity);
-    tcase_add_test(tc_basic, test_skipped_external_entity);
-    tcase_add_test(tc_basic, test_skipped_null_loaded_ext_entity);
-    tcase_add_test(tc_basic, test_skipped_unloaded_ext_entity);
-    tcase_add_test(tc_basic, test_param_entity_with_trailing_cr);
-    tcase_add_test(tc_basic, test_invalid_character_entity);
-    tcase_add_test(tc_basic, test_invalid_character_entity_2);
-    tcase_add_test(tc_basic, test_invalid_character_entity_3);
-    tcase_add_test(tc_basic, test_invalid_character_entity_4);
-    tcase_add_test(tc_basic, test_pi_handled_in_default);
-    tcase_add_test(tc_basic, test_comment_handled_in_default);
-    tcase_add_test(tc_basic, test_pi_yml);
-    tcase_add_test(tc_basic, test_pi_xnl);
-    tcase_add_test(tc_basic, test_pi_xmm);
-    tcase_add_test(tc_basic, test_utf16_pi);
-    tcase_add_test(tc_basic, test_utf16_be_pi);
-    tcase_add_test(tc_basic, test_utf16_be_comment);
-    tcase_add_test(tc_basic, test_utf16_le_comment);
-    tcase_add_test(tc_basic, test_missing_encoding_conversion_fn);
-    tcase_add_test(tc_basic, test_failing_encoding_conversion_fn);
-    tcase_add_test(tc_basic, test_unknown_encoding_success);
-    tcase_add_test(tc_basic, test_unknown_encoding_bad_name);
-    tcase_add_test(tc_basic, test_unknown_encoding_bad_name_2);
-    tcase_add_test(tc_basic, test_unknown_encoding_long_name_1);
-    tcase_add_test(tc_basic, test_unknown_encoding_long_name_2);
-    tcase_add_test(tc_basic, test_invalid_unknown_encoding);
-    tcase_add_test(tc_basic, test_unknown_ascii_encoding_ok);
-    tcase_add_test(tc_basic, test_unknown_ascii_encoding_fail);
-    tcase_add_test(tc_basic, test_unknown_encoding_invalid_length);
-    tcase_add_test(tc_basic, test_unknown_encoding_invalid_topbit);
-    tcase_add_test(tc_basic, test_unknown_encoding_invalid_surrogate);
-    tcase_add_test(tc_basic, test_unknown_encoding_invalid_high);
-    tcase_add_test(tc_basic, test_unknown_encoding_invalid_attr_value);
-    tcase_add_test(tc_basic, test_ext_entity_latin1_utf16le_bom);
-    tcase_add_test(tc_basic, test_ext_entity_latin1_utf16be_bom);
-    tcase_add_test(tc_basic, test_ext_entity_latin1_utf16le_bom2);
-    tcase_add_test(tc_basic, test_ext_entity_latin1_utf16be_bom2);
-    tcase_add_test(tc_basic, test_ext_entity_utf16_be);
-    tcase_add_test(tc_basic, test_ext_entity_utf16_le);
-    tcase_add_test(tc_basic, test_ext_entity_utf16_unknown);
-    tcase_add_test(tc_basic, test_ext_entity_utf8_non_bom);
-    tcase_add_test(tc_basic, test_utf8_in_cdata_section);
-    tcase_add_test(tc_basic, test_utf8_in_cdata_section_2);
-    tcase_add_test(tc_basic, test_trailing_spaces_in_elements);
-    tcase_add_test(tc_basic, test_utf16_attribute);
-    tcase_add_test(tc_basic, test_utf16_second_attr);
-    tcase_add_test(tc_basic, test_attr_after_solidus);
-    tcase_add_test(tc_basic, test_utf16_pe);
-    tcase_add_test(tc_basic, test_bad_attr_desc_keyword);
-    tcase_add_test(tc_basic, test_bad_attr_desc_keyword_utf16);
-    tcase_add_test(tc_basic, test_bad_doctype);
-    tcase_add_test(tc_basic, test_bad_doctype_utf16);
-    tcase_add_test(tc_basic, test_bad_doctype_plus);
-    tcase_add_test(tc_basic, test_bad_doctype_star);
-    tcase_add_test(tc_basic, test_bad_doctype_query);
-    tcase_add_test(tc_basic, test_unknown_encoding_bad_ignore);
-    tcase_add_test(tc_basic, test_entity_in_utf16_be_attr);
-    tcase_add_test(tc_basic, test_entity_in_utf16_le_attr);
-    tcase_add_test(tc_basic, test_entity_public_utf16_be);
-    tcase_add_test(tc_basic, test_entity_public_utf16_le);
-    tcase_add_test(tc_basic, test_short_doctype);
-    tcase_add_test(tc_basic, test_short_doctype_2);
-    tcase_add_test(tc_basic, test_short_doctype_3);
-    tcase_add_test(tc_basic, test_long_doctype);
-    tcase_add_test(tc_basic, test_bad_entity);
-    tcase_add_test(tc_basic, test_bad_entity_2);
-    tcase_add_test(tc_basic, test_bad_entity_3);
-    tcase_add_test(tc_basic, test_bad_entity_4);
-    tcase_add_test(tc_basic, test_bad_notation);
-    tcase_add_test(tc_basic, test_default_doctype_handler);
-    tcase_add_test(tc_basic, test_empty_element_abort);
-
-    suite_add_tcase(s, tc_namespace);
-    tcase_add_checked_fixture(tc_namespace,
-                              namespace_setup, namespace_teardown);
-    tcase_add_test(tc_namespace, test_return_ns_triplet);
-    tcase_add_test(tc_namespace, test_ns_tagname_overwrite);
-    tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet);
-    tcase_add_test(tc_namespace, test_start_ns_clears_start_element);
-    tcase_add_test(tc_namespace, test_default_ns_from_ext_subset_and_ext_ge);
-    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_1);
-    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_2);
-    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_3);
-    tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_4);
-    tcase_add_test(tc_namespace, test_ns_unbound_prefix);
-    tcase_add_test(tc_namespace, test_ns_default_with_empty_uri);
-    tcase_add_test(tc_namespace, test_ns_duplicate_attrs_diff_prefixes);
-    tcase_add_test(tc_namespace, test_ns_duplicate_hashes);
-    tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_attribute);
-    tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_element);
-    tcase_add_test(tc_namespace, test_ns_parser_reset);
-    tcase_add_test(tc_namespace, test_ns_long_element);
-    tcase_add_test(tc_namespace, test_ns_mixed_prefix_atts);
-    tcase_add_test(tc_namespace, test_ns_extend_uri_buffer);
-    tcase_add_test(tc_namespace, test_ns_reserved_attributes);
-    tcase_add_test(tc_namespace, test_ns_reserved_attributes_2);
-    tcase_add_test(tc_namespace, test_ns_extremely_long_prefix);
-    tcase_add_test(tc_namespace, test_ns_unknown_encoding_success);
-    tcase_add_test(tc_namespace, test_ns_double_colon);
-    tcase_add_test(tc_namespace, test_ns_double_colon_element);
-    tcase_add_test(tc_namespace, test_ns_bad_attr_leafname);
-    tcase_add_test(tc_namespace, test_ns_bad_element_leafname);
-    tcase_add_test(tc_namespace, test_ns_utf16_leafname);
-    tcase_add_test(tc_namespace, test_ns_utf16_element_leafname);
-    tcase_add_test(tc_namespace, test_ns_utf16_doctype);
-    tcase_add_test(tc_namespace, test_ns_invalid_doctype);
-    tcase_add_test(tc_namespace, test_ns_double_colon_doctype);
-
-    suite_add_tcase(s, tc_misc);
-    tcase_add_checked_fixture(tc_misc, NULL, basic_teardown);
-    tcase_add_test(tc_misc, test_misc_alloc_create_parser);
-    tcase_add_test(tc_misc, test_misc_alloc_create_parser_with_encoding);
-    tcase_add_test(tc_misc, test_misc_null_parser);
-    tcase_add_test(tc_misc, test_misc_error_string);
-    tcase_add_test(tc_misc, test_misc_version);
-    tcase_add_test(tc_misc, test_misc_features);
-    tcase_add_test(tc_misc, test_misc_attribute_leak);
-    tcase_add_test(tc_misc, test_misc_utf16le);
-
-    suite_add_tcase(s, tc_alloc);
-    tcase_add_checked_fixture(tc_alloc, alloc_setup, alloc_teardown);
-    tcase_add_test(tc_alloc, test_alloc_parse_xdecl);
-    tcase_add_test(tc_alloc, test_alloc_parse_xdecl_2);
-    tcase_add_test(tc_alloc, test_alloc_parse_pi);
-    tcase_add_test(tc_alloc, test_alloc_parse_pi_2);
-    tcase_add_test(tc_alloc, test_alloc_parse_pi_3);
-    tcase_add_test(tc_alloc, test_alloc_parse_comment);
-    tcase_add_test(tc_alloc, test_alloc_parse_comment_2);
-    tcase_add_test(tc_alloc, test_alloc_create_external_parser);
-    tcase_add_test(tc_alloc, test_alloc_run_external_parser);
-    tcase_add_test(tc_alloc, test_alloc_dtd_copy_default_atts);
-    tcase_add_test(tc_alloc, test_alloc_external_entity);
-    tcase_add_test(tc_alloc, test_alloc_ext_entity_set_encoding);
-    tcase_add_test(tc_alloc, test_alloc_internal_entity);
-    tcase_add_test(tc_alloc, test_alloc_dtd_default_handling);
-    tcase_add_test(tc_alloc, test_alloc_explicit_encoding);
-    tcase_add_test(tc_alloc, test_alloc_set_base);
-    tcase_add_test(tc_alloc, test_alloc_realloc_buffer);
-    tcase_add_test(tc_alloc, test_alloc_ext_entity_realloc_buffer);
-    tcase_add_test(tc_alloc, test_alloc_realloc_many_attributes);
-    tcase_add_test(tc_alloc, test_alloc_public_entity_value);
-    tcase_add_test(tc_alloc, test_alloc_realloc_subst_public_entity_value);
-    tcase_add_test(tc_alloc, test_alloc_parse_public_doctype);
-    tcase_add_test(tc_alloc, test_alloc_parse_public_doctype_long_name);
-    tcase_add_test(tc_alloc, test_alloc_set_foreign_dtd);
-    tcase_add_test(tc_alloc, test_alloc_attribute_enum_value);
-    tcase_add_test(tc_alloc, test_alloc_realloc_attribute_enum_value);
-    tcase_add_test(tc_alloc, test_alloc_realloc_implied_attribute);
-    tcase_add_test(tc_alloc, test_alloc_realloc_default_attribute);
-    tcase_add_test(tc_alloc, test_alloc_notation);
-    tcase_add_test(tc_alloc, test_alloc_public_notation);
-    tcase_add_test(tc_alloc, test_alloc_system_notation);
-    tcase_add_test(tc_alloc, test_alloc_nested_groups);
-    tcase_add_test(tc_alloc, test_alloc_realloc_nested_groups);
-    tcase_add_test(tc_alloc, test_alloc_large_group);
-    tcase_add_test(tc_alloc, test_alloc_realloc_group_choice);
-    tcase_add_test(tc_alloc, test_alloc_pi_in_epilog);
-    tcase_add_test(tc_alloc, test_alloc_comment_in_epilog);
-    tcase_add_test(tc_alloc, test_alloc_realloc_long_attribute_value);
-    tcase_add_test(tc_alloc, test_alloc_attribute_whitespace);
-    tcase_add_test(tc_alloc, test_alloc_attribute_predefined_entity);
-    tcase_add_test(tc_alloc, test_alloc_long_attr_default_with_char_ref);
-    tcase_add_test(tc_alloc, test_alloc_long_attr_value);
-    tcase_add_test(tc_alloc, test_alloc_nested_entities);
-    tcase_add_test(tc_alloc, test_alloc_realloc_param_entity_newline);
-    tcase_add_test(tc_alloc, test_alloc_realloc_ce_extends_pe);
-    tcase_add_test(tc_alloc, test_alloc_realloc_attributes);
-    tcase_add_test(tc_alloc, test_alloc_long_doc_name);
-    tcase_add_test(tc_alloc, test_alloc_long_base);
-    tcase_add_test(tc_alloc, test_alloc_long_public_id);
-    tcase_add_test(tc_alloc, test_alloc_long_entity_value);
-    tcase_add_test(tc_alloc, test_alloc_long_notation);
-
-    suite_add_tcase(s, tc_nsalloc);
-    tcase_add_checked_fixture(tc_nsalloc, nsalloc_setup, nsalloc_teardown);
-    tcase_add_test(tc_nsalloc, test_nsalloc_xmlns);
-    tcase_add_test(tc_nsalloc, test_nsalloc_parse_buffer);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_prefix);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_uri);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_attr);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_attr_prefix);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_attributes);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_element);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_binding_uri);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_prefix);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_longer_prefix);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_namespace);
-    tcase_add_test(tc_nsalloc, test_nsalloc_less_long_namespace);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_context);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_2);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_3);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_4);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_5);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_6);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_7);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_ge_name);
-    tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_in_dtd);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_default_in_ext);
-    tcase_add_test(tc_nsalloc, test_nsalloc_long_systemid_in_ext);
-    tcase_add_test(tc_nsalloc, test_nsalloc_prefixed_element);
-
-    return s;
-}
+make_suite(void) {
+  Suite *s = suite_create("basic");
+  TCase *tc_basic = tcase_create("basic tests");
+  TCase *tc_namespace = tcase_create("XML namespaces");
+  TCase *tc_misc = tcase_create("miscellaneous tests");
+  TCase *tc_alloc = tcase_create("allocation tests");
+  TCase *tc_nsalloc = tcase_create("namespace allocation tests");
+
+  suite_add_tcase(s, tc_basic);
+  tcase_add_checked_fixture(tc_basic, basic_setup, basic_teardown);
+  tcase_add_test(tc_basic, test_nul_byte);
+  tcase_add_test(tc_basic, test_u0000_char);
+  tcase_add_test(tc_basic, test_siphash_self);
+  tcase_add_test(tc_basic, test_siphash_spec);
+  tcase_add_test(tc_basic, test_bom_utf8);
+  tcase_add_test(tc_basic, test_bom_utf16_be);
+  tcase_add_test(tc_basic, test_bom_utf16_le);
+  tcase_add_test(tc_basic, test_nobom_utf16_le);
+  tcase_add_test(tc_basic, test_illegal_utf8);
+  tcase_add_test(tc_basic, test_utf8_auto_align);
+  tcase_add_test(tc_basic, test_utf16);
+  tcase_add_test(tc_basic, test_utf16_le_epilog_newline);
+  tcase_add_test(tc_basic, test_not_utf16);
+  tcase_add_test(tc_basic, test_bad_encoding);
+  tcase_add_test(tc_basic, test_latin1_umlauts);
+  tcase_add_test(tc_basic, test_long_utf8_character);
+  tcase_add_test(tc_basic, test_long_latin1_attribute);
+  tcase_add_test(tc_basic, test_long_ascii_attribute);
+  /* Regression test for SF bug #491986. */
+  tcase_add_test(tc_basic, test_danish_latin1);
+  /* Regression test for SF bug #514281. */
+  tcase_add_test(tc_basic, test_french_charref_hexidecimal);
+  tcase_add_test(tc_basic, test_french_charref_decimal);
+  tcase_add_test(tc_basic, test_french_latin1);
+  tcase_add_test(tc_basic, test_french_utf8);
+  tcase_add_test(tc_basic, test_utf8_false_rejection);
+  tcase_add_test(tc_basic, test_line_number_after_parse);
+  tcase_add_test(tc_basic, test_column_number_after_parse);
+  tcase_add_test(tc_basic, test_line_and_column_numbers_inside_handlers);
+  tcase_add_test(tc_basic, test_line_number_after_error);
+  tcase_add_test(tc_basic, test_column_number_after_error);
+  tcase_add_test(tc_basic, test_really_long_lines);
+  tcase_add_test(tc_basic, test_really_long_encoded_lines);
+  tcase_add_test(tc_basic, test_end_element_events);
+  tcase_add_test(tc_basic, test_attr_whitespace_normalization);
+  tcase_add_test(tc_basic, test_xmldecl_misplaced);
+  tcase_add_test(tc_basic, test_xmldecl_invalid);
+  tcase_add_test(tc_basic, test_xmldecl_missing_attr);
+  tcase_add_test(tc_basic, test_xmldecl_missing_value);
+  tcase_add_test(tc_basic, test_unknown_encoding_internal_entity);
+  tcase_add_test(tc_basic, test_unrecognised_encoding_internal_entity);
+  tcase_add_test(tc_basic, test_wfc_undeclared_entity_unread_external_subset);
+  tcase_add_test(tc_basic, test_wfc_undeclared_entity_no_external_subset);
+  tcase_add_test(tc_basic, test_wfc_undeclared_entity_standalone);
+  tcase_add_test(tc_basic, test_wfc_undeclared_entity_with_external_subset);
+  tcase_add_test(tc_basic, test_not_standalone_handler_reject);
+  tcase_add_test(tc_basic, test_not_standalone_handler_accept);
+  tcase_add_test(tc_basic,
+                 test_wfc_undeclared_entity_with_external_subset_standalone);
+  tcase_add_test(tc_basic, test_entity_with_external_subset_unless_standalone);
+  tcase_add_test(tc_basic, test_wfc_no_recursive_entity_refs);
+  tcase_add_test(tc_basic, test_ext_entity_set_encoding);
+  tcase_add_test(tc_basic, test_ext_entity_no_handler);
+  tcase_add_test(tc_basic, test_ext_entity_set_bom);
+  tcase_add_test(tc_basic, test_ext_entity_bad_encoding);
+  tcase_add_test(tc_basic, test_ext_entity_bad_encoding_2);
+  tcase_add_test(tc_basic, test_ext_entity_invalid_parse);
+  tcase_add_test(tc_basic, test_ext_entity_invalid_suspended_parse);
+  tcase_add_test(tc_basic, test_dtd_default_handling);
+  tcase_add_test(tc_basic, test_dtd_attr_handling);
+  tcase_add_test(tc_basic, test_empty_ns_without_namespaces);
+  tcase_add_test(tc_basic, test_ns_in_attribute_default_without_namespaces);
+  tcase_add_test(tc_basic, test_stop_parser_between_char_data_calls);
+  tcase_add_test(tc_basic, test_suspend_parser_between_char_data_calls);
+  tcase_add_test(tc_basic, test_repeated_stop_parser_between_char_data_calls);
+  tcase_add_test(tc_basic, test_good_cdata_ascii);
+  tcase_add_test(tc_basic, test_good_cdata_utf16);
+  tcase_add_test(tc_basic, test_good_cdata_utf16_le);
+  tcase_add_test(tc_basic, test_long_cdata_utf16);
+#ifndef XML_MIN_SIZE /* FIXME workaround -DXML_MIN_SIZE + ASan (issue #332) */
+  tcase_add_test(tc_basic, test_multichar_cdata_utf16);
+#endif
+  tcase_add_test(tc_basic, test_utf16_bad_surrogate_pair);
+  tcase_add_test(tc_basic, test_bad_cdata);
+#ifndef XML_MIN_SIZE /* FIXME workaround -DXML_MIN_SIZE + ASan (issue #332) */
+  tcase_add_test(tc_basic, test_bad_cdata_utf16);
+#endif
+  tcase_add_test(tc_basic, test_stop_parser_between_cdata_calls);
+  tcase_add_test(tc_basic, test_suspend_parser_between_cdata_calls);
+  tcase_add_test(tc_basic, test_memory_allocation);
+  tcase_add_test(tc_basic, test_default_current);
+  tcase_add_test(tc_basic, test_dtd_elements);
+  tcase_add_test(tc_basic, test_set_foreign_dtd);
+  tcase_add_test(tc_basic, test_foreign_dtd_not_standalone);
+  tcase_add_test(tc_basic, test_invalid_foreign_dtd);
+  tcase_add_test(tc_basic, test_foreign_dtd_with_doctype);
+  tcase_add_test(tc_basic, test_foreign_dtd_without_external_subset);
+  tcase_add_test(tc_basic, test_empty_foreign_dtd);
+  tcase_add_test(tc_basic, test_set_base);
+  tcase_add_test(tc_basic, test_attributes);
+  tcase_add_test(tc_basic, test_reset_in_entity);
+  tcase_add_test(tc_basic, test_resume_invalid_parse);
+  tcase_add_test(tc_basic, test_resume_resuspended);
+  tcase_add_test(tc_basic, test_cdata_default);
+  tcase_add_test(tc_basic, test_subordinate_reset);
+  tcase_add_test(tc_basic, test_subordinate_suspend);
+  tcase_add_test(tc_basic, test_subordinate_xdecl_suspend);
+  tcase_add_test(tc_basic, test_subordinate_xdecl_abort);
+  tcase_add_test(tc_basic, test_explicit_encoding);
+  tcase_add_test(tc_basic, test_trailing_cr);
+  tcase_add_test(tc_basic, test_ext_entity_trailing_cr);
+  tcase_add_test(tc_basic, test_trailing_rsqb);
+  tcase_add_test(tc_basic, test_ext_entity_trailing_rsqb);
+  tcase_add_test(tc_basic, test_ext_entity_good_cdata);
+  tcase_add_test(tc_basic, test_user_parameters);
+  tcase_add_test(tc_basic, test_ext_entity_ref_parameter);
+  tcase_add_test(tc_basic, test_empty_parse);
+  tcase_add_test(tc_basic, test_get_buffer_1);
+  tcase_add_test(tc_basic, test_get_buffer_2);
+  tcase_add_test(tc_basic, test_byte_info_at_end);
+  tcase_add_test(tc_basic, test_byte_info_at_error);
+  tcase_add_test(tc_basic, test_byte_info_at_cdata);
+  tcase_add_test(tc_basic, test_predefined_entities);
+  tcase_add_test(tc_basic, test_invalid_tag_in_dtd);
+  tcase_add_test(tc_basic, test_not_predefined_entities);
+  tcase_add_test(tc_basic, test_ignore_section);
+  tcase_add_test(tc_basic, test_ignore_section_utf16);
+  tcase_add_test(tc_basic, test_ignore_section_utf16_be);
+  tcase_add_test(tc_basic, test_bad_ignore_section);
+  tcase_add_test(tc_basic, test_external_entity_values);
+  tcase_add_test(tc_basic, test_ext_entity_not_standalone);
+  tcase_add_test(tc_basic, test_ext_entity_value_abort);
+  tcase_add_test(tc_basic, test_bad_public_doctype);
+  tcase_add_test(tc_basic, test_attribute_enum_value);
+  tcase_add_test(tc_basic, test_predefined_entity_redefinition);
+  tcase_add_test(tc_basic, test_dtd_stop_processing);
+  tcase_add_test(tc_basic, test_public_notation_no_sysid);
+  tcase_add_test(tc_basic, test_nested_groups);
+  tcase_add_test(tc_basic, test_group_choice);
+  tcase_add_test(tc_basic, test_standalone_parameter_entity);
+  tcase_add_test(tc_basic, test_skipped_parameter_entity);
+  tcase_add_test(tc_basic, test_recursive_external_parameter_entity);
+  tcase_add_test(tc_basic, test_undefined_ext_entity_in_external_dtd);
+  tcase_add_test(tc_basic, test_suspend_xdecl);
+  tcase_add_test(tc_basic, test_abort_epilog);
+  tcase_add_test(tc_basic, test_abort_epilog_2);
+  tcase_add_test(tc_basic, test_suspend_epilog);
+  tcase_add_test(tc_basic, test_suspend_in_sole_empty_tag);
+  tcase_add_test(tc_basic, test_unfinished_epilog);
+  tcase_add_test(tc_basic, test_partial_char_in_epilog);
+  tcase_add_test(tc_basic, test_hash_collision);
+  tcase_add_test(tc_basic, test_suspend_resume_internal_entity);
+  tcase_add_test(tc_basic, test_resume_entity_with_syntax_error);
+  tcase_add_test(tc_basic, test_suspend_resume_parameter_entity);
+  tcase_add_test(tc_basic, test_restart_on_error);
+  tcase_add_test(tc_basic, test_reject_lt_in_attribute_value);
+  tcase_add_test(tc_basic, test_reject_unfinished_param_in_att_value);
+  tcase_add_test(tc_basic, test_trailing_cr_in_att_value);
+  tcase_add_test(tc_basic, test_standalone_internal_entity);
+  tcase_add_test(tc_basic, test_skipped_external_entity);
+  tcase_add_test(tc_basic, test_skipped_null_loaded_ext_entity);
+  tcase_add_test(tc_basic, test_skipped_unloaded_ext_entity);
+  tcase_add_test(tc_basic, test_param_entity_with_trailing_cr);
+  tcase_add_test(tc_basic, test_invalid_character_entity);
+  tcase_add_test(tc_basic, test_invalid_character_entity_2);
+  tcase_add_test(tc_basic, test_invalid_character_entity_3);
+  tcase_add_test(tc_basic, test_invalid_character_entity_4);
+  tcase_add_test(tc_basic, test_pi_handled_in_default);
+  tcase_add_test(tc_basic, test_comment_handled_in_default);
+  tcase_add_test(tc_basic, test_pi_yml);
+  tcase_add_test(tc_basic, test_pi_xnl);
+  tcase_add_test(tc_basic, test_pi_xmm);
+  tcase_add_test(tc_basic, test_utf16_pi);
+  tcase_add_test(tc_basic, test_utf16_be_pi);
+  tcase_add_test(tc_basic, test_utf16_be_comment);
+  tcase_add_test(tc_basic, test_utf16_le_comment);
+  tcase_add_test(tc_basic, test_missing_encoding_conversion_fn);
+  tcase_add_test(tc_basic, test_failing_encoding_conversion_fn);
+  tcase_add_test(tc_basic, test_unknown_encoding_success);
+  tcase_add_test(tc_basic, test_unknown_encoding_bad_name);
+  tcase_add_test(tc_basic, test_unknown_encoding_bad_name_2);
+  tcase_add_test(tc_basic, test_unknown_encoding_long_name_1);
+  tcase_add_test(tc_basic, test_unknown_encoding_long_name_2);
+  tcase_add_test(tc_basic, test_invalid_unknown_encoding);
+  tcase_add_test(tc_basic, test_unknown_ascii_encoding_ok);
+  tcase_add_test(tc_basic, test_unknown_ascii_encoding_fail);
+  tcase_add_test(tc_basic, test_unknown_encoding_invalid_length);
+  tcase_add_test(tc_basic, test_unknown_encoding_invalid_topbit);
+  tcase_add_test(tc_basic, test_unknown_encoding_invalid_surrogate);
+  tcase_add_test(tc_basic, test_unknown_encoding_invalid_high);
+  tcase_add_test(tc_basic, test_unknown_encoding_invalid_attr_value);
+  tcase_add_test(tc_basic, test_ext_entity_latin1_utf16le_bom);
+  tcase_add_test(tc_basic, test_ext_entity_latin1_utf16be_bom);
+  tcase_add_test(tc_basic, test_ext_entity_latin1_utf16le_bom2);
+  tcase_add_test(tc_basic, test_ext_entity_latin1_utf16be_bom2);
+  tcase_add_test(tc_basic, test_ext_entity_utf16_be);
+  tcase_add_test(tc_basic, test_ext_entity_utf16_le);
+  tcase_add_test(tc_basic, test_ext_entity_utf16_unknown);
+  tcase_add_test(tc_basic, test_ext_entity_utf8_non_bom);
+  tcase_add_test(tc_basic, test_utf8_in_cdata_section);
+  tcase_add_test(tc_basic, test_utf8_in_cdata_section_2);
+  tcase_add_test(tc_basic, test_trailing_spaces_in_elements);
+  tcase_add_test(tc_basic, test_utf16_attribute);
+  tcase_add_test(tc_basic, test_utf16_second_attr);
+  tcase_add_test(tc_basic, test_attr_after_solidus);
+  tcase_add_test(tc_basic, test_utf16_pe);
+  tcase_add_test(tc_basic, test_bad_attr_desc_keyword);
+  tcase_add_test(tc_basic, test_bad_attr_desc_keyword_utf16);
+  tcase_add_test(tc_basic, test_bad_doctype);
+  tcase_add_test(tc_basic, test_bad_doctype_utf16);
+  tcase_add_test(tc_basic, test_bad_doctype_plus);
+  tcase_add_test(tc_basic, test_bad_doctype_star);
+  tcase_add_test(tc_basic, test_bad_doctype_query);
+  tcase_add_test(tc_basic, test_unknown_encoding_bad_ignore);
+  tcase_add_test(tc_basic, test_entity_in_utf16_be_attr);
+  tcase_add_test(tc_basic, test_entity_in_utf16_le_attr);
+  tcase_add_test(tc_basic, test_entity_public_utf16_be);
+  tcase_add_test(tc_basic, test_entity_public_utf16_le);
+  tcase_add_test(tc_basic, test_short_doctype);
+  tcase_add_test(tc_basic, test_short_doctype_2);
+  tcase_add_test(tc_basic, test_short_doctype_3);
+  tcase_add_test(tc_basic, test_long_doctype);
+  tcase_add_test(tc_basic, test_bad_entity);
+  tcase_add_test(tc_basic, test_bad_entity_2);
+  tcase_add_test(tc_basic, test_bad_entity_3);
+  tcase_add_test(tc_basic, test_bad_entity_4);
+  tcase_add_test(tc_basic, test_bad_notation);
+  tcase_add_test(tc_basic, test_default_doctype_handler);
+  tcase_add_test(tc_basic, test_empty_element_abort);
+
+  suite_add_tcase(s, tc_namespace);
+  tcase_add_checked_fixture(tc_namespace, namespace_setup, namespace_teardown);
+  tcase_add_test(tc_namespace, test_return_ns_triplet);
+  tcase_add_test(tc_namespace, test_ns_tagname_overwrite);
+  tcase_add_test(tc_namespace, test_ns_tagname_overwrite_triplet);
+  tcase_add_test(tc_namespace, test_start_ns_clears_start_element);
+  tcase_add_test(tc_namespace, test_default_ns_from_ext_subset_and_ext_ge);
+  tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_1);
+  tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_2);
+  tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_3);
+  tcase_add_test(tc_namespace, test_ns_prefix_with_empty_uri_4);
+  tcase_add_test(tc_namespace, test_ns_unbound_prefix);
+  tcase_add_test(tc_namespace, test_ns_default_with_empty_uri);
+  tcase_add_test(tc_namespace, test_ns_duplicate_attrs_diff_prefixes);
+  tcase_add_test(tc_namespace, test_ns_duplicate_hashes);
+  tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_attribute);
+  tcase_add_test(tc_namespace, test_ns_unbound_prefix_on_element);
+  tcase_add_test(tc_namespace, test_ns_parser_reset);
+  tcase_add_test(tc_namespace, test_ns_long_element);
+  tcase_add_test(tc_namespace, test_ns_mixed_prefix_atts);
+  tcase_add_test(tc_namespace, test_ns_extend_uri_buffer);
+  tcase_add_test(tc_namespace, test_ns_reserved_attributes);
+  tcase_add_test(tc_namespace, test_ns_reserved_attributes_2);
+  tcase_add_test(tc_namespace, test_ns_extremely_long_prefix);
+  tcase_add_test(tc_namespace, test_ns_unknown_encoding_success);
+  tcase_add_test(tc_namespace, test_ns_double_colon);
+  tcase_add_test(tc_namespace, test_ns_double_colon_element);
+  tcase_add_test(tc_namespace, test_ns_bad_attr_leafname);
+  tcase_add_test(tc_namespace, test_ns_bad_element_leafname);
+  tcase_add_test(tc_namespace, test_ns_utf16_leafname);
+  tcase_add_test(tc_namespace, test_ns_utf16_element_leafname);
+  tcase_add_test(tc_namespace, test_ns_utf16_doctype);
+  tcase_add_test(tc_namespace, test_ns_invalid_doctype);
+  tcase_add_test(tc_namespace, test_ns_double_colon_doctype);
+
+  suite_add_tcase(s, tc_misc);
+  tcase_add_checked_fixture(tc_misc, NULL, basic_teardown);
+  tcase_add_test(tc_misc, test_misc_alloc_create_parser);
+  tcase_add_test(tc_misc, test_misc_alloc_create_parser_with_encoding);
+  tcase_add_test(tc_misc, test_misc_null_parser);
+  tcase_add_test(tc_misc, test_misc_error_string);
+  tcase_add_test(tc_misc, test_misc_version);
+  tcase_add_test(tc_misc, test_misc_features);
+  tcase_add_test(tc_misc, test_misc_attribute_leak);
+  tcase_add_test(tc_misc, test_misc_utf16le);
+  tcase_add_test(tc_misc, test_misc_stop_during_end_handler_issue_240_1);
+  tcase_add_test(tc_misc, test_misc_stop_during_end_handler_issue_240_2);
+#ifdef XML_DTD
+  tcase_add_test(tc_misc,
+                 test_misc_deny_internal_entity_closing_doctype_issue_317);
+#endif
 
+  suite_add_tcase(s, tc_alloc);
+  tcase_add_checked_fixture(tc_alloc, alloc_setup, alloc_teardown);
+  tcase_add_test(tc_alloc, test_alloc_parse_xdecl);
+  tcase_add_test(tc_alloc, test_alloc_parse_xdecl_2);
+  tcase_add_test(tc_alloc, test_alloc_parse_pi);
+  tcase_add_test(tc_alloc, test_alloc_parse_pi_2);
+  tcase_add_test(tc_alloc, test_alloc_parse_pi_3);
+  tcase_add_test(tc_alloc, test_alloc_parse_comment);
+  tcase_add_test(tc_alloc, test_alloc_parse_comment_2);
+  tcase_add_test(tc_alloc, test_alloc_create_external_parser);
+  tcase_add_test(tc_alloc, test_alloc_run_external_parser);
+  tcase_add_test(tc_alloc, test_alloc_dtd_copy_default_atts);
+  tcase_add_test(tc_alloc, test_alloc_external_entity);
+  tcase_add_test(tc_alloc, test_alloc_ext_entity_set_encoding);
+  tcase_add_test(tc_alloc, test_alloc_internal_entity);
+  tcase_add_test(tc_alloc, test_alloc_dtd_default_handling);
+  tcase_add_test(tc_alloc, test_alloc_explicit_encoding);
+  tcase_add_test(tc_alloc, test_alloc_set_base);
+  tcase_add_test(tc_alloc, test_alloc_realloc_buffer);
+  tcase_add_test(tc_alloc, test_alloc_ext_entity_realloc_buffer);
+  tcase_add_test(tc_alloc, test_alloc_realloc_many_attributes);
+  tcase_add_test(tc_alloc, test_alloc_public_entity_value);
+  tcase_add_test(tc_alloc, test_alloc_realloc_subst_public_entity_value);
+  tcase_add_test(tc_alloc, test_alloc_parse_public_doctype);
+  tcase_add_test(tc_alloc, test_alloc_parse_public_doctype_long_name);
+  tcase_add_test(tc_alloc, test_alloc_set_foreign_dtd);
+  tcase_add_test(tc_alloc, test_alloc_attribute_enum_value);
+  tcase_add_test(tc_alloc, test_alloc_realloc_attribute_enum_value);
+  tcase_add_test(tc_alloc, test_alloc_realloc_implied_attribute);
+  tcase_add_test(tc_alloc, test_alloc_realloc_default_attribute);
+  tcase_add_test(tc_alloc, test_alloc_notation);
+  tcase_add_test(tc_alloc, test_alloc_public_notation);
+  tcase_add_test(tc_alloc, test_alloc_system_notation);
+  tcase_add_test(tc_alloc, test_alloc_nested_groups);
+  tcase_add_test(tc_alloc, test_alloc_realloc_nested_groups);
+  tcase_add_test(tc_alloc, test_alloc_large_group);
+  tcase_add_test(tc_alloc, test_alloc_realloc_group_choice);
+  tcase_add_test(tc_alloc, test_alloc_pi_in_epilog);
+  tcase_add_test(tc_alloc, test_alloc_comment_in_epilog);
+  tcase_add_test(tc_alloc, test_alloc_realloc_long_attribute_value);
+  tcase_add_test(tc_alloc, test_alloc_attribute_whitespace);
+  tcase_add_test(tc_alloc, test_alloc_attribute_predefined_entity);
+  tcase_add_test(tc_alloc, test_alloc_long_attr_default_with_char_ref);
+  tcase_add_test(tc_alloc, test_alloc_long_attr_value);
+  tcase_add_test(tc_alloc, test_alloc_nested_entities);
+  tcase_add_test(tc_alloc, test_alloc_realloc_param_entity_newline);
+  tcase_add_test(tc_alloc, test_alloc_realloc_ce_extends_pe);
+  tcase_add_test(tc_alloc, test_alloc_realloc_attributes);
+  tcase_add_test(tc_alloc, test_alloc_long_doc_name);
+  tcase_add_test(tc_alloc, test_alloc_long_base);
+  tcase_add_test(tc_alloc, test_alloc_long_public_id);
+  tcase_add_test(tc_alloc, test_alloc_long_entity_value);
+  tcase_add_test(tc_alloc, test_alloc_long_notation);
+
+  suite_add_tcase(s, tc_nsalloc);
+  tcase_add_checked_fixture(tc_nsalloc, nsalloc_setup, nsalloc_teardown);
+  tcase_add_test(tc_nsalloc, test_nsalloc_xmlns);
+  tcase_add_test(tc_nsalloc, test_nsalloc_parse_buffer);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_prefix);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_uri);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_attr);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_attr_prefix);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_attributes);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_element);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_binding_uri);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_prefix);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_longer_prefix);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_namespace);
+  tcase_add_test(tc_nsalloc, test_nsalloc_less_long_namespace);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_context);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_2);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_3);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_4);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_5);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_6);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_7);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_ge_name);
+  tcase_add_test(tc_nsalloc, test_nsalloc_realloc_long_context_in_dtd);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_default_in_ext);
+  tcase_add_test(tc_nsalloc, test_nsalloc_long_systemid_in_ext);
+  tcase_add_test(tc_nsalloc, test_nsalloc_prefixed_element);
+
+  return s;
+}
 
 int
-main(int argc, char *argv[])
-{
-    int i, nf;
-    int verbosity = CK_NORMAL;
-    Suite *s = make_suite();
-    SRunner *sr = srunner_create(s);
-
-    /* run the tests for internal helper functions */
-    testhelper_is_whitespace_normalized();
-
-    for (i = 1; i < argc; ++i) {
-        char *opt = argv[i];
-        if (strcmp(opt, "-v") == 0 || strcmp(opt, "--verbose") == 0)
-            verbosity = CK_VERBOSE;
-        else if (strcmp(opt, "-q") == 0 || strcmp(opt, "--quiet") == 0)
-            verbosity = CK_SILENT;
-        else {
-            fprintf(stderr, "runtests: unknown option '%s'\n", opt);
-            return 2;
-        }
+main(int argc, char *argv[]) {
+  int i, nf;
+  int verbosity = CK_NORMAL;
+  Suite *s = make_suite();
+  SRunner *sr = srunner_create(s);
+
+  /* run the tests for internal helper functions */
+  testhelper_is_whitespace_normalized();
+
+  for (i = 1; i < argc; ++i) {
+    char *opt = argv[i];
+    if (strcmp(opt, "-v") == 0 || strcmp(opt, "--verbose") == 0)
+      verbosity = CK_VERBOSE;
+    else if (strcmp(opt, "-q") == 0 || strcmp(opt, "--quiet") == 0)
+      verbosity = CK_SILENT;
+    else {
+      fprintf(stderr, "runtests: unknown option '%s'\n", opt);
+      return 2;
     }
-    if (verbosity != CK_SILENT)
-        printf("Expat version: %" XML_FMT_STR "\n", XML_ExpatVersion());
-    srunner_run_all(sr, verbosity);
-    nf = srunner_ntests_failed(sr);
-    srunner_free(sr);
+  }
+  if (verbosity != CK_SILENT)
+    printf("Expat version: %" XML_FMT_STR "\n", XML_ExpatVersion());
+  srunner_run_all(sr, verbosity);
+  nf = srunner_ntests_failed(sr);
+  srunner_free(sr);
 
-    return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+  return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
 }
diff --git a/contrib/expat/tests/structdata.c b/contrib/expat/tests/structdata.c
index 2ed36fc38de8..e81b7b184601 100644
--- a/contrib/expat/tests/structdata.c
+++ b/contrib/expat/tests/structdata.c
@@ -31,10 +31,9 @@
 */
 
 #ifdef HAVE_EXPAT_CONFIG_H
-# include "expat_config.h"
+#  include "expat_config.h"
 #endif
 
-
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -46,117 +45,111 @@
 #define STRUCT_EXTENSION_COUNT 8
 
 #ifdef XML_UNICODE_WCHAR_T
-# include <wchar.h>
-# define XML_FMT_STR "ls"
-# define xcstrlen(s) wcslen(s)
-# define xcstrcmp(s, t) wcscmp((s), (t))
+#  include <wchar.h>
+#  define XML_FMT_STR "ls"
+#  define xcstrlen(s) wcslen(s)
+#  define xcstrcmp(s, t) wcscmp((s), (t))
 #else
-# define XML_FMT_STR "s"
-# define xcstrlen(s) strlen(s)
-# define xcstrcmp(s, t) strcmp((s), (t))
+#  define XML_FMT_STR "s"
+#  define xcstrlen(s) strlen(s)
+#  define xcstrcmp(s, t) strcmp((s), (t))
 #endif
 
-
 static XML_Char *
-xmlstrdup(const XML_Char *s)
-{
-    size_t byte_count = (xcstrlen(s) + 1) * sizeof(XML_Char);
-    XML_Char *dup = malloc(byte_count);
-
-    assert(dup != NULL);
-    memcpy(dup, s, byte_count);
-    return dup;
-}
+xmlstrdup(const XML_Char *s) {
+  size_t byte_count = (xcstrlen(s) + 1) * sizeof(XML_Char);
+  XML_Char *dup = malloc(byte_count);
 
+  assert(dup != NULL);
+  memcpy(dup, s, byte_count);
+  return dup;
+}
 
 void
-StructData_Init(StructData *storage)
-{
-    assert(storage != NULL);
-    storage->count = 0;
-    storage->max_count = 0;
-    storage->entries = NULL;
+StructData_Init(StructData *storage) {
+  assert(storage != NULL);
+  storage->count = 0;
+  storage->max_count = 0;
+  storage->entries = NULL;
 }
 
 void
-StructData_AddItem(StructData *storage,
-                   const XML_Char *s,
-                   int data0,
-                   int data1,
-                   int data2)
-{
-    StructDataEntry *entry;
-
-    assert(storage != NULL);
-    assert(s != NULL);
-    if (storage->count == storage->max_count) {
-        StructDataEntry *new;
-
-        storage->max_count += STRUCT_EXTENSION_COUNT;
-        new = realloc(storage->entries,
-                      storage->max_count * sizeof(StructDataEntry));
-        assert(new != NULL);
-        storage->entries = new;
-    }
-
-    entry = &storage->entries[storage->count];
-    entry->str = xmlstrdup(s);
-    entry->data0 = data0;
-    entry->data1 = data1;
-    entry->data2 = data2;
-    storage->count++;
+StructData_AddItem(StructData *storage, const XML_Char *s, int data0, int data1,
+                   int data2) {
+  StructDataEntry *entry;
+
+  assert(storage != NULL);
+  assert(s != NULL);
+  if (storage->count == storage->max_count) {
+    StructDataEntry *new;
+
+    storage->max_count += STRUCT_EXTENSION_COUNT;
+    new = realloc(storage->entries,
+                  storage->max_count * sizeof(StructDataEntry));
+    assert(new != NULL);
+    storage->entries = new;
+  }
+
+  entry = &storage->entries[storage->count];
+  entry->str = xmlstrdup(s);
+  entry->data0 = data0;
+  entry->data1 = data1;
+  entry->data2 = data2;
+  storage->count++;
 }
 
 /* 'fail()' aborts the function via a longjmp, so there is no point
  * in returning a value from this function.
  */
 void
-StructData_CheckItems(StructData *storage,
-                      const StructDataEntry *expected,
-                      int count)
-{
-    char buffer[1024];
-    int i;
-
-    assert(storage != NULL);
-    assert(expected != NULL);
-    if (count != storage->count) {
-        sprintf(buffer, "wrong number of entries: got %d, expected %d",
-                storage->count, count);
+StructData_CheckItems(StructData *storage, const StructDataEntry *expected,
+                      int count) {
+  char buffer[1024];
+  int i;
+
+  assert(storage != NULL);
+  assert(expected != NULL);
+  if (count != storage->count) {
+    sprintf(buffer, "wrong number of entries: got %d, expected %d",
+            storage->count, count);
+    StructData_Dispose(storage);
+    fail(buffer);
+  } else {
+    for (i = 0; i < count; i++) {
+      const StructDataEntry *got = &storage->entries[i];
+      const StructDataEntry *want = &expected[i];
+
+      assert(got != NULL);
+      assert(want != NULL);
+
+      if (xcstrcmp(got->str, want->str) != 0) {
         StructData_Dispose(storage);
-        fail(buffer);
-    }
-    for (i = 0; i < count; i++)
-    {
-        const StructDataEntry *got = &storage->entries[i];
-        const StructDataEntry *want = &expected[i];
-
-        if (xcstrcmp(got->str, want->str) != 0) {
-            StructData_Dispose(storage);
-            fail("structure got bad string");
-        }
-        if (got->data0 != want->data0 ||
-            got->data1 != want->data1 ||
-            got->data2 != want->data2) {
-            sprintf(buffer,
-                    "struct '%" XML_FMT_STR
-                    "' expected (%d,%d,%d), got (%d,%d,%d)",
-                    got->str,
-                    want->data0, want->data1, want->data2,
-                    got->data0, got->data1, got->data2);
-            StructData_Dispose(storage);
-            fail(buffer);
+        fail("structure got bad string");
+      } else {
+        if (got->data0 != want->data0 || got->data1 != want->data1
+            || got->data2 != want->data2) {
+          sprintf(buffer,
+                  "struct '%" XML_FMT_STR
+                  "' expected (%d,%d,%d), got (%d,%d,%d)",
+                  got->str, want->data0, want->data1, want->data2, got->data0,
+                  got->data1, got->data2);
+          StructData_Dispose(storage);
+          fail(buffer);
         }
+      }
     }
+  }
 }
 
 void
-StructData_Dispose(StructData *storage)
-{
-    int i;
-
-    assert(storage != NULL);
-    for (i = 0; i < storage->count; i++)
-        free((void *)storage->entries[i].str);
-    free(storage->entries);
+StructData_Dispose(StructData *storage) {
+  int i;
+
+  assert(storage != NULL);
+  for (i = 0; i < storage->count; i++)
+    free((void *)storage->entries[i].str);
+  free(storage->entries);
+
+  storage->count = 0;
+  storage->entries = NULL;
 }
diff --git a/contrib/expat/tests/structdata.h b/contrib/expat/tests/structdata.h
index 19016a9195c7..870ffaf2af05 100644
--- a/contrib/expat/tests/structdata.h
+++ b/contrib/expat/tests/structdata.h
@@ -36,40 +36,34 @@ extern "C" {
 #endif
 
 #ifndef XML_STRUCTDATA_H
-#define XML_STRUCTDATA_H 1
+#  define XML_STRUCTDATA_H 1
 
-#include "expat.h"
+#  include "expat.h"
 
 typedef struct {
-    const XML_Char *str;
-    int data0;
-    int data1;
-    int data2;
+  const XML_Char *str;
+  int data0;
+  int data1;
+  int data2;
 } StructDataEntry;
 
 typedef struct {
-    int count;       /* Number of entries used */
-    int max_count;   /* Number of StructDataEntry items in `entries` */
-    StructDataEntry *entries;
+  int count;     /* Number of entries used */
+  int max_count; /* Number of StructDataEntry items in `entries` */
+  StructDataEntry *entries;
 } StructData;
 
-
 void StructData_Init(StructData *storage);
 
-void StructData_AddItem(StructData *storage,
-                        const XML_Char *s,
-                        int data0,
-                        int data1,
-                        int data2);
+void StructData_AddItem(StructData *storage, const XML_Char *s, int data0,
+                        int data1, int data2);
 
-void StructData_CheckItems(StructData *storage,
-                           const StructDataEntry *expected,
+void StructData_CheckItems(StructData *storage, const StructDataEntry *expected,
                            int count);
 
 void StructData_Dispose(StructData *storage);
 
-
-#endif  /* XML_STRUCTDATA_H */
+#endif /* XML_STRUCTDATA_H */
 
 #ifdef __cplusplus
 }
diff --git a/contrib/expat/tests/xmltest.sh b/contrib/expat/tests/xmltest.sh
index 2b8cb196b385..9b5003511430 100755
--- a/contrib/expat/tests/xmltest.sh
+++ b/contrib/expat/tests/xmltest.sh
@@ -22,17 +22,16 @@
 
 shopt -s nullglob
 
+# Note: OUTPUT must terminate with the directory separator.
+OUTPUT="$PWD/tests/out/"
+TS="$PWD/tests/"
+
 MYDIR="`dirname \"$0\"`"
 cd "$MYDIR"
 MYDIR="`pwd`"
 XMLWF="${1:-`dirname \"$MYDIR\"`/xmlwf/xmlwf}"
-# XMLWF=/usr/local/bin/xmlwf
-TS="$MYDIR"
-# OUTPUT must terminate with the directory separator.
-OUTPUT="$TS/out/"
-# OUTPUT=/home/tmp/xml-testsuite-out/
 # Unicode-aware diff utility
-DIFF="$TS/udiffer.py"
+DIFF="${MYDIR}/udiffer.py"
 
 
 # RunXmlwfNotWF file reldir
@@ -40,9 +39,7 @@ DIFF="$TS/udiffer.py"
 RunXmlwfNotWF() {
   file="$1"
   reldir="$2"
-  $XMLWF -p "$file" > outfile || return $?
-  read outdata < outfile
-  if test "$outdata" = "" ; then
+  if $XMLWF -p "$file" > /dev/null; then
       echo "Expected not well-formed: $reldir$file"
       return 1
   else
@@ -133,7 +130,6 @@ for xmldir in ibm/not-wf/P* \
       RunXmlwfNotWF "$xmlfile" "$xmldir/"
       UpdateStatus $?
   done
-  rm outfile
 done
 
 cd "$TS/xmlconf/oasis"
@@ -141,7 +137,6 @@ for xmlfile in *fail*.xml ; do
     RunXmlwfNotWF "$xmlfile" "oasis/"
     UpdateStatus $?
 done
-rm outfile
 
 echo "Passed: $SUCCESS"
 echo "Failed: $ERROR"
diff --git a/contrib/expat/xmlwf/Makefile.am b/contrib/expat/xmlwf/Makefile.am
index ff460902caa0..4b41c2cbdab8 100644
--- a/contrib/expat/xmlwf/Makefile.am
+++ b/contrib/expat/xmlwf/Makefile.am
@@ -56,6 +56,4 @@ EXTRA_DIST = \
     xmlfile.h \
     xmlmime.c \
     xmlmime.h \
-    xmltchar.h \
-    xmlurl.h \
-    xmlwin32url.cxx
+    xmltchar.h
diff --git a/contrib/expat/xmlwf/Makefile.in b/contrib/expat/xmlwf/Makefile.in
index 152bbe97eec3..368d3777431d 100644
--- a/contrib/expat/xmlwf/Makefile.in
+++ b/contrib/expat/xmlwf/Makefile.in
@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.15.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2017 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -125,7 +125,14 @@ ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
 	$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
-	$(top_srcdir)/conftools/ac_c_bigendian_cross.m4 \
+	$(top_srcdir)/acinclude.m4 \
+	$(top_srcdir)/conftools/ax-require-defined.m4 \
+	$(top_srcdir)/conftools/ax-check-compile-flag.m4 \
+	$(top_srcdir)/conftools/ax-check-link-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-flag.m4 \
+	$(top_srcdir)/conftools/ax-append-compile-flags.m4 \
+	$(top_srcdir)/conftools/ax-append-link-flags.m4 \
+	$(top_srcdir)/conftools/expatcfg-compiler-supports-visibility.m4 \
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
@@ -161,7 +168,10 @@ am__v_at_0 = @
 am__v_at_1 = 
 DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
 depcomp = $(SHELL) $(top_srcdir)/conftools/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/xmlwf-@FILEMAP@.Po \
+	./$(DEPDIR)/xmlwf-codepage.Po ./$(DEPDIR)/xmlwf-xmlfile.Po \
+	./$(DEPDIR)/xmlwf-xmlwf.Po
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -355,9 +365,7 @@ EXTRA_DIST = \
     xmlfile.h \
     xmlmime.c \
     xmlmime.h \
-    xmltchar.h \
-    xmlurl.h \
-    xmlwin32url.cxx
+    xmltchar.h
 
 all: all-am
 
@@ -380,8 +388,8 @@ Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	  *config.status*) \
 	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -452,10 +460,16 @@ mostlyclean-compile:
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-@FILEMAP@.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-codepage.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-xmlfile.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-xmlwf.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-@FILEMAP@.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-codepage.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-xmlfile.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/xmlwf-xmlwf.Po@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@@ -592,7 +606,10 @@ cscopelist-am: $(am__tagged_files)
 distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
@@ -664,7 +681,10 @@ clean: clean-am
 clean-am: clean-binPROGRAMS clean-generic clean-libtool mostlyclean-am
 
 distclean: distclean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/xmlwf-@FILEMAP@.Po
+	-rm -f ./$(DEPDIR)/xmlwf-codepage.Po
+	-rm -f ./$(DEPDIR)/xmlwf-xmlfile.Po
+	-rm -f ./$(DEPDIR)/xmlwf-xmlwf.Po
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-tags
@@ -710,7 +730,10 @@ install-ps-am:
 installcheck-am:
 
 maintainer-clean: maintainer-clean-am
-	-rm -rf ./$(DEPDIR)
+		-rm -f ./$(DEPDIR)/xmlwf-@FILEMAP@.Po
+	-rm -f ./$(DEPDIR)/xmlwf-codepage.Po
+	-rm -f ./$(DEPDIR)/xmlwf-xmlfile.Po
+	-rm -f ./$(DEPDIR)/xmlwf-xmlwf.Po
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -731,7 +754,7 @@ uninstall-am: uninstall-binPROGRAMS
 
 .MAKE: install-am install-strip
 
-.PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
+.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \
 	clean-binPROGRAMS clean-generic clean-libtool cscopelist-am \
 	ctags ctags-am distclean distclean-compile distclean-generic \
 	distclean-libtool distclean-tags distdir dvi dvi-am html \
diff --git a/contrib/expat/xmlwf/codepage.c b/contrib/expat/xmlwf/codepage.c
index 1a0487ff91d2..1095adf63eb2 100644
--- a/contrib/expat/xmlwf/codepage.c
+++ b/contrib/expat/xmlwf/codepage.c
@@ -31,25 +31,24 @@
 */
 
 #include "codepage.h"
-#include "internal.h"  /* for UNUSED_P only */
+#include "internal.h" /* for UNUSED_P only */
 
 #if defined(_WIN32)
-#define STRICT 1
-#define WIN32_LEAN_AND_MEAN 1
+#  define STRICT 1
+#  define WIN32_LEAN_AND_MEAN 1
 
-#include <windows.h>
+#  include <windows.h>
 
 int
-codepageMap(int cp, int *map)
-{
+codepageMap(int cp, int *map) {
   int i;
   CPINFO info;
-  if (!GetCPInfo(cp, &info) || info.MaxCharSize > 2)
+  if (! GetCPInfo(cp, &info) || info.MaxCharSize > 2)
     return 0;
   for (i = 0; i < 256; i++)
     map[i] = -1;
   if (info.MaxCharSize > 1) {
-    for (i = 0; i < MAX_LEADBYTES; i+=2) {
+    for (i = 0; i < MAX_LEADBYTES; i += 2) {
       int j, lim;
       if (info.LeadByte[i] == 0 && info.LeadByte[i + 1] == 0)
         break;
@@ -59,23 +58,24 @@ codepageMap(int cp, int *map)
     }
   }
   for (i = 0; i < 256; i++) {
-   if (map[i] == -1) {
-     char c = (char)i;
-     unsigned short n;
-     if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
-                             &c, 1, &n, 1) == 1)
-       map[i] = n;
-   }
+    if (map[i] == -1) {
+      char c = (char)i;
+      unsigned short n;
+      if (MultiByteToWideChar(cp, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, &c, 1,
+                              &n, 1)
+          == 1)
+        map[i] = n;
+    }
   }
   return 1;
 }
 
 int
-codepageConvert(int cp, const char *p)
-{
+codepageConvert(int cp, const char *p) {
   unsigned short c;
-  if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
-                          p, 2, &c, 1) == 1)
+  if (MultiByteToWideChar(cp, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, p, 2, &c,
+                          1)
+      == 1)
     return c;
   return -1;
 }
@@ -83,14 +83,16 @@ codepageConvert(int cp, const char *p)
 #else /* not _WIN32 */
 
 int
-codepageMap(int UNUSED_P(cp), int *UNUSED_P(map))
-{
+codepageMap(int cp, int *map) {
+  UNUSED_P(cp);
+  UNUSED_P(map);
   return 0;
 }
 
 int
-codepageConvert(int UNUSED_P(cp), const char *UNUSED_P(p))
-{
+codepageConvert(int cp, const char *p) {
+  UNUSED_P(cp);
+  UNUSED_P(p);
   return -1;
 }
 
diff --git a/contrib/expat/xmlwf/ct.c b/contrib/expat/xmlwf/ct.c
index dd42f5ec98d8..dcf92bab568b 100644
--- a/contrib/expat/xmlwf/ct.c
+++ b/contrib/expat/xmlwf/ct.c
@@ -33,8 +33,7 @@
 #define CHARSET_MAX 41
 
 static const char *
-getTok(const char **pp)
-{
+getTok(const char **pp) {
   enum { inAtom, inString, init, inComment };
   int state = init;
   const char *tokStart = 0;
@@ -102,9 +101,8 @@ getTok(const char **pp)
 /* key must be lowercase ASCII */
 
 static int
-matchkey(const char *start, const char *end, const char *key)
-{
-  if (!start)
+matchkey(const char *start, const char *end, const char *key) {
+  if (! start)
     return 0;
   for (; start != end; start++, key++)
     if (*start != *key && *start != 'A' + (*key - 'a'))
@@ -113,8 +111,7 @@ matchkey(const char *start, const char *end, const char *key)
 }
 
 void
-getXMLCharset(const char *buf, char *charset)
-{
+getXMLCharset(const char *buf, char *charset) {
   const char *next, *p;
 
   charset[0] = '\0';
@@ -122,10 +119,10 @@ getXMLCharset(const char *buf, char *charset)
   p = getTok(&next);
   if (matchkey(p, next, "text"))
     strcpy(charset, "us-ascii");
-  else if (!matchkey(p, next, "application"))
+  else if (! matchkey(p, next, "application"))
     return;
   p = getTok(&next);
-  if (!p || *p != '/')
+  if (! p || *p != '/')
     return;
   p = getTok(&next);
   if (matchkey(p, next, "xml"))
@@ -151,8 +148,7 @@ getXMLCharset(const char *buf, char *charset)
                 *s++ = *p;
               }
               *s++ = '\0';
-            }
-            else {
+            } else {
               if (next - p > CHARSET_MAX - 1)
                 break;
               while (p != next)
@@ -163,15 +159,13 @@ getXMLCharset(const char *buf, char *charset)
           }
         }
       }
-    }
-  else
-    p = getTok(&next);
+    } else
+      p = getTok(&next);
   }
 }
 
 int
-main(int argc, char **argv)
-{
+main(int argc, char **argv) {
   char buf[CHARSET_MAX];
   getXMLCharset(argv[1], buf);
   printf("charset = \"%s\"\n", buf);
diff --git a/contrib/expat/xmlwf/filemap.h b/contrib/expat/xmlwf/filemap.h
index 5487a4ebe50b..ef66114422f3 100644
--- a/contrib/expat/xmlwf/filemap.h
+++ b/contrib/expat/xmlwf/filemap.h
@@ -30,10 +30,9 @@
    USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-#include <limits.h>  /* INT_MAX */
+#include <limits.h> /* INT_MAX */
 #include <stddef.h>
 
-
 /* The following limit (for XML_Parse's int len) derives from
  * this loop in xmparse.c:
  *
@@ -41,17 +40,14 @@
  *      bufferSize = (int) (2U * (unsigned) bufferSize);
  *    } while (bufferSize < neededSize && bufferSize > 0);
  */
-#define XML_MAX_CHUNK_LEN  (INT_MAX / 2 + 1)
-
+#define XML_MAX_CHUNK_LEN (INT_MAX / 2 + 1)
 
 #ifdef XML_UNICODE
 int filemap(const wchar_t *name,
-            void (*processor)(const void *, size_t,
-                              const wchar_t *, void *arg),
+            void (*processor)(const void *, size_t, const wchar_t *, void *arg),
             void *arg);
 #else
 int filemap(const char *name,
-            void (*processor)(const void *, size_t,
-                              const char *, void *arg),
+            void (*processor)(const void *, size_t, const char *, void *arg),
             void *arg);
 #endif
diff --git a/contrib/expat/xmlwf/readfilemap.c b/contrib/expat/xmlwf/readfilemap.c
index 4c4780bde0e3..d5b84f995ad4 100644
--- a/contrib/expat/xmlwf/readfilemap.c
+++ b/contrib/expat/xmlwf/readfilemap.c
@@ -37,40 +37,40 @@
 #include <stdio.h>
 
 /* Functions close(2) and read(2) */
-#if !defined(_WIN32) && !defined(_WIN64)
-# include <unistd.h>
+#if ! defined(_WIN32) && ! defined(_WIN64)
+#  include <unistd.h>
 #endif
 
 /* Function "read": */
 #if defined(_MSC_VER)
-# include <io.h>
-  /* https://msdn.microsoft.com/en-us/library/wyssk1bs(v=vs.100).aspx */
-# define _EXPAT_read          _read
-# define _EXPAT_read_count_t  int
-# define _EXPAT_read_req_t    unsigned int
-#else  /* POSIX */
-  /* http://pubs.opengroup.org/onlinepubs/009695399/functions/read.html */
-# define _EXPAT_read          read
-# define _EXPAT_read_count_t  ssize_t
-# define _EXPAT_read_req_t    size_t
+#  include <io.h>
+/* https://msdn.microsoft.com/en-us/library/wyssk1bs(v=vs.100).aspx */
+#  define _EXPAT_read _read
+#  define _EXPAT_read_count_t int
+#  define _EXPAT_read_req_t unsigned int
+#else /* POSIX */
+/* http://pubs.opengroup.org/onlinepubs/009695399/functions/read.html */
+#  define _EXPAT_read read
+#  define _EXPAT_read_count_t ssize_t
+#  define _EXPAT_read_req_t size_t
 #endif
 
 #ifndef S_ISREG
-# ifndef S_IFREG
-#  define S_IFREG _S_IFREG
-# endif
-# ifndef S_IFMT
-#  define S_IFMT _S_IFMT
-# endif
-# define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
+#  ifndef S_IFREG
+#    define S_IFREG _S_IFREG
+#  endif
+#  ifndef S_IFMT
+#    define S_IFMT _S_IFMT
+#  endif
+#  define S_ISREG(m) (((m)&S_IFMT) == S_IFREG)
 #endif /* not S_ISREG */
 
 #ifndef O_BINARY
-# ifdef _O_BINARY
-#  define O_BINARY _O_BINARY
-# else
-#  define O_BINARY 0
-# endif
+#  ifdef _O_BINARY
+#    define O_BINARY _O_BINARY
+#  else
+#    define O_BINARY 0
+#  endif
 #endif
 
 #include "xmltchar.h"
@@ -79,15 +79,14 @@
 int
 filemap(const tchar *name,
         void (*processor)(const void *, size_t, const tchar *, void *arg),
-        void *arg)
-{
+        void *arg) {
   size_t nbytes;
   int fd;
   _EXPAT_read_count_t n;
   struct stat sb;
   void *p;
 
-  fd = topen(name, O_RDONLY|O_BINARY);
+  fd = topen(name, O_RDONLY | O_BINARY);
   if (fd < 0) {
     tperror(name);
     return 0;
@@ -97,14 +96,14 @@ filemap(const tchar *name,
     close(fd);
     return 0;
   }
-  if (!S_ISREG(sb.st_mode)) {
+  if (! S_ISREG(sb.st_mode)) {
     ftprintf(stderr, T("%s: not a regular file\n"), name);
     close(fd);
     return 0;
   }
   if (sb.st_size > XML_MAX_CHUNK_LEN) {
     close(fd);
-    return 2;  /* Cannot be passed to XML_Parse in one go */
+    return 2; /* Cannot be passed to XML_Parse in one go */
   }
 
   nbytes = sb.st_size;
@@ -116,7 +115,7 @@ filemap(const tchar *name,
     return 1;
   }
   p = malloc(nbytes);
-  if (!p) {
+  if (! p) {
     ftprintf(stderr, T("%s: out of memory\n"), name);
     close(fd);
     return 0;
diff --git a/contrib/expat/xmlwf/unixfilemap.c b/contrib/expat/xmlwf/unixfilemap.c
index 4ab757c2ab9c..0d0dc0424dc0 100644
--- a/contrib/expat/xmlwf/unixfilemap.c
+++ b/contrib/expat/xmlwf/unixfilemap.c
@@ -40,23 +40,22 @@
 #include <unistd.h>
 
 #ifndef MAP_FILE
-#define MAP_FILE 0
+#  define MAP_FILE 0
 #endif
 
 #include "xmltchar.h"
 #include "filemap.h"
 
 #ifdef XML_UNICODE_WCHAR_T
-# define XML_FMT_STR "ls"
+#  define XML_FMT_STR "ls"
 #else
-# define XML_FMT_STR "s"
+#  define XML_FMT_STR "s"
 #endif
 
 int
 filemap(const tchar *name,
         void (*processor)(const void *, size_t, const tchar *, void *arg),
-        void *arg)
-{
+        void *arg) {
   int fd;
   size_t nbytes;
   struct stat sb;
@@ -72,14 +71,14 @@ filemap(const tchar *name,
     close(fd);
     return 0;
   }
-  if (!S_ISREG(sb.st_mode)) {
+  if (! S_ISREG(sb.st_mode)) {
     close(fd);
     fprintf(stderr, "%" XML_FMT_STR ": not a regular file\n", name);
     return 0;
   }
   if (sb.st_size > XML_MAX_CHUNK_LEN) {
     close(fd);
-    return 2;  /* Cannot be passed to XML_Parse in one go */
+    return 2; /* Cannot be passed to XML_Parse in one go */
   }
 
   nbytes = sb.st_size;
@@ -90,8 +89,8 @@ filemap(const tchar *name,
     close(fd);
     return 1;
   }
-  p = (void *)mmap((void *)0, (size_t)nbytes, PROT_READ,
-                   MAP_FILE|MAP_PRIVATE, fd, (off_t)0);
+  p = (void *)mmap((void *)0, (size_t)nbytes, PROT_READ, MAP_FILE | MAP_PRIVATE,
+                   fd, (off_t)0);
   if (p == (void *)-1) {
     tperror(name);
     close(fd);
diff --git a/contrib/expat/xmlwf/win32filemap.c b/contrib/expat/xmlwf/win32filemap.c
index a040a097db4c..0c9b7ecc5ffb 100644
--- a/contrib/expat/xmlwf/win32filemap.c
+++ b/contrib/expat/xmlwf/win32filemap.c
@@ -34,14 +34,14 @@
 #define WIN32_LEAN_AND_MEAN 1
 
 #ifdef XML_UNICODE_WCHAR_T
-# ifndef XML_UNICODE
-#  define XML_UNICODE
-# endif
+#  ifndef XML_UNICODE
+#    define XML_UNICODE
+#  endif
 #endif
 
 #ifdef XML_UNICODE
-# define UNICODE
-# define _UNICODE
+#  define UNICODE
+#  define _UNICODE
 #endif /* XML_UNICODE */
 #include <windows.h>
 #include <stdio.h>
@@ -53,8 +53,7 @@ static void win32perror(const TCHAR *);
 int
 filemap(const TCHAR *name,
         void (*processor)(const void *, size_t, const TCHAR *, void *arg),
-        void *arg)
-{
+        void *arg) {
   HANDLE f;
   HANDLE m;
   DWORD size;
@@ -62,7 +61,7 @@ filemap(const TCHAR *name,
   void *p;
 
   f = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
-                          FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+                 FILE_FLAG_SEQUENTIAL_SCAN, NULL);
   if (f == INVALID_HANDLE_VALUE) {
     win32perror(name);
     return 0;
@@ -75,7 +74,7 @@ filemap(const TCHAR *name,
   }
   if (sizeHi || (size > XML_MAX_CHUNK_LEN)) {
     CloseHandle(f);
-    return 2;  /* Cannot be passed to XML_Parse in one go */
+    return 2; /* Cannot be passed to XML_Parse in one go */
   }
   /* CreateFileMapping barfs on zero length files */
   if (size == 0) {
@@ -97,7 +96,7 @@ filemap(const TCHAR *name,
     CloseHandle(f);
     return 0;
   }
-  processor(p, size, name, arg); 
+  processor(p, size, name, arg);
   UnmapViewOfFile(p);
   CloseHandle(m);
   CloseHandle(f);
@@ -105,21 +104,15 @@ filemap(const TCHAR *name,
 }
 
 static void
-win32perror(const TCHAR *s)
-{
+win32perror(const TCHAR *s) {
   LPVOID buf;
-  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
-                    | FORMAT_MESSAGE_FROM_SYSTEM,
-                    NULL,
-                    GetLastError(),
-                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-                    (LPTSTR) &buf,
-                    0,
+  if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+                    NULL, GetLastError(),
+                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR)&buf, 0,
                     NULL)) {
     _ftprintf(stderr, _T("%s: %s"), s, buf);
     fflush(stderr);
     LocalFree(buf);
-  }
-  else
+  } else
     _ftprintf(stderr, _T("%s: unknown Windows error\n"), s);
 }
diff --git a/contrib/expat/xmlwf/xmlfile.c b/contrib/expat/xmlwf/xmlfile.c
index 4075f5710cad..922e18b0b7e2 100644
--- a/contrib/expat/xmlwf/xmlfile.c
+++ b/contrib/expat/xmlwf/xmlfile.c
@@ -37,87 +37,77 @@
 #include <fcntl.h>
 
 #ifdef _WIN32
-#include "winconfig.h"
+#  include "winconfig.h"
 #elif defined(HAVE_EXPAT_CONFIG_H)
-#include <expat_config.h>
+#  include <expat_config.h>
 #endif /* ndef _WIN32 */
 
 #include "expat.h"
-#include "internal.h"  /* for UNUSED_P only */
+#include "internal.h" /* for UNUSED_P only */
 #include "xmlfile.h"
 #include "xmltchar.h"
 #include "filemap.h"
 
 #if defined(_MSC_VER)
-#include <io.h>
+#  include <io.h>
 #endif
 
 #ifdef HAVE_UNISTD_H
-#include <unistd.h>
+#  include <unistd.h>
 #endif
 
 #ifndef O_BINARY
-#ifdef _O_BINARY
-#define O_BINARY _O_BINARY
-#else
-#define O_BINARY 0
-#endif
+#  ifdef _O_BINARY
+#    define O_BINARY _O_BINARY
+#  else
+#    define O_BINARY 0
+#  endif
 #endif
 
 #ifdef _DEBUG
-#define READ_SIZE 16
+#  define READ_SIZE 16
 #else
-#define READ_SIZE (1024*8)
+#  define READ_SIZE (1024 * 8)
 #endif
 
-
 typedef struct {
   XML_Parser parser;
   int *retPtr;
 } PROCESS_ARGS;
 
-static int
-processStream(const XML_Char *filename, XML_Parser parser);
+static int processStream(const XML_Char *filename, XML_Parser parser);
 
 static void
-reportError(XML_Parser parser, const XML_Char *filename)
-{
+reportError(XML_Parser parser, const XML_Char *filename) {
   enum XML_Error code = XML_GetErrorCode(parser);
   const XML_Char *message = XML_ErrorString(code);
   if (message)
     ftprintf(stdout,
-             T("%s")
-               T(":%") T(XML_FMT_INT_MOD) T("u")
-               T(":%") T(XML_FMT_INT_MOD) T("u")
-               T(": %s\n"),
-             filename,
-             XML_GetErrorLineNumber(parser),
-             XML_GetErrorColumnNumber(parser),
-             message);
+             T("%s") T(":%") T(XML_FMT_INT_MOD) T("u") T(":%")
+                 T(XML_FMT_INT_MOD) T("u") T(": %s\n"),
+             filename, XML_GetErrorLineNumber(parser),
+             XML_GetErrorColumnNumber(parser), message);
   else
     ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
 }
- 
+
 /* This implementation will give problems on files larger than INT_MAX. */
 static void
-processFile(const void *data, size_t size,
-            const XML_Char *filename, void *args)
-{
+processFile(const void *data, size_t size, const XML_Char *filename,
+            void *args) {
   XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
   int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
   if (XML_Parse(parser, (const char *)data, (int)size, 1) == XML_STATUS_ERROR) {
     reportError(parser, filename);
     *retPtr = 0;
-  }
-  else
+  } else
     *retPtr = 1;
 }
 
 #if defined(_WIN32)
 
 static int
-isAsciiLetter(XML_Char c)
-{
+isAsciiLetter(XML_Char c) {
   return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
 }
 
@@ -125,21 +115,19 @@ isAsciiLetter(XML_Char c)
 
 static const XML_Char *
 resolveSystemId(const XML_Char *base, const XML_Char *systemId,
-                XML_Char **toFree)
-{
+                XML_Char **toFree) {
   XML_Char *s;
   *toFree = 0;
-  if (!base
-      || *systemId == T('/')
+  if (! base || *systemId == T('/')
 #if defined(_WIN32)
       || *systemId == T('\\')
       || (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
 #endif
-     )
+  )
     return systemId;
   *toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)
                                * sizeof(XML_Char));
-  if (!*toFree)
+  if (! *toFree)
     return systemId;
   tcscpy(*toFree, base);
   s = *toFree;
@@ -154,18 +142,16 @@ resolveSystemId(const XML_Char *base, const XML_Char *systemId,
 }
 
 static int
-externalEntityRefFilemap(XML_Parser parser,
-                         const XML_Char *context,
-                         const XML_Char *base,
-                         const XML_Char *systemId,
-                         const XML_Char *UNUSED_P(publicId))
-{
+externalEntityRefFilemap(XML_Parser parser, const XML_Char *context,
+                         const XML_Char *base, const XML_Char *systemId,
+                         const XML_Char *publicId) {
   int result;
   XML_Char *s;
   const XML_Char *filename;
   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
   int filemapRes;
   PROCESS_ARGS args;
+  UNUSED_P(publicId);
   args.retPtr = &result;
   args.parser = entParser;
   filename = resolveSystemId(base, systemId, &s);
@@ -176,8 +162,10 @@ externalEntityRefFilemap(XML_Parser parser,
     result = 0;
     break;
   case 2:
-    ftprintf(stderr, T("%s: file too large for memory-mapping")
-        T(", switching to streaming\n"), filename);
+    ftprintf(stderr,
+             T("%s: file too large for memory-mapping")
+                 T(", switching to streaming\n"),
+             filename);
     result = processStream(filename, entParser);
     break;
   }
@@ -187,13 +175,12 @@ externalEntityRefFilemap(XML_Parser parser,
 }
 
 static int
-processStream(const XML_Char *filename, XML_Parser parser)
-{
+processStream(const XML_Char *filename, XML_Parser parser) {
   /* passing NULL for filename means read intput from stdin */
-  int fd = 0;   /* 0 is the fileno for stdin */
+  int fd = 0; /* 0 is the fileno for stdin */
 
   if (filename != NULL) {
-    fd = topen(filename, O_BINARY|O_RDONLY);
+    fd = topen(filename, O_BINARY | O_RDONLY);
     if (fd < 0) {
       tperror(filename);
       return 0;
@@ -202,7 +189,7 @@ processStream(const XML_Char *filename, XML_Parser parser)
   for (;;) {
     int nread;
     char *buf = (char *)XML_GetBuffer(parser, READ_SIZE);
-    if (!buf) {
+    if (! buf) {
       if (filename != NULL)
         close(fd);
       ftprintf(stderr, T("%s: out of memory\n"),
@@ -217,7 +204,7 @@ processStream(const XML_Char *filename, XML_Parser parser)
       return 0;
     }
     if (XML_ParseBuffer(parser, nread, nread == 0) == XML_STATUS_ERROR) {
-        reportError(parser, filename != NULL ? filename : T("STDIN"));
+      reportError(parser, filename != NULL ? filename : T("STDIN"));
       if (filename != NULL)
         close(fd);
       return 0;
@@ -225,23 +212,22 @@ processStream(const XML_Char *filename, XML_Parser parser)
     if (nread == 0) {
       if (filename != NULL)
         close(fd);
-      break;;
+      break;
+      ;
     }
   }
   return 1;
 }
 
 static int
-externalEntityRefStream(XML_Parser parser,
-                        const XML_Char *context,
-                        const XML_Char *base,
-                        const XML_Char *systemId,
-                        const XML_Char *UNUSED_P(publicId))
-{
+externalEntityRefStream(XML_Parser parser, const XML_Char *context,
+                        const XML_Char *base, const XML_Char *systemId,
+                        const XML_Char *publicId) {
   XML_Char *s;
   const XML_Char *filename;
   int ret;
   XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
+  UNUSED_P(publicId);
   filename = resolveSystemId(base, systemId, &s);
   XML_SetBase(entParser, filename);
   ret = processStream(filename, entParser);
@@ -251,22 +237,18 @@ externalEntityRefStream(XML_Parser parser,
 }
 
 int
-XML_ProcessFile(XML_Parser parser,
-                const XML_Char *filename,
-                unsigned flags)
-{
+XML_ProcessFile(XML_Parser parser, const XML_Char *filename, unsigned flags) {
   int result;
 
-  if (!XML_SetBase(parser, filename)) {
+  if (! XML_SetBase(parser, filename)) {
     ftprintf(stderr, T("%s: out of memory"), filename);
     exit(1);
   }
 
   if (flags & XML_EXTERNAL_ENTITIES)
-      XML_SetExternalEntityRefHandler(parser,
-                                      (flags & XML_MAP_FILE)
-                                      ? externalEntityRefFilemap
-                                      : externalEntityRefStream);
+    XML_SetExternalEntityRefHandler(parser, (flags & XML_MAP_FILE)
+                                                ? externalEntityRefFilemap
+                                                : externalEntityRefStream);
   if (flags & XML_MAP_FILE) {
     int filemapRes;
     PROCESS_ARGS args;
@@ -278,13 +260,14 @@ XML_ProcessFile(XML_Parser parser,
       result = 0;
       break;
     case 2:
-      ftprintf(stderr, T("%s: file too large for memory-mapping")
-          T(", switching to streaming\n"), filename);
+      ftprintf(stderr,
+               T("%s: file too large for memory-mapping")
+                   T(", switching to streaming\n"),
+               filename);
       result = processStream(filename, parser);
       break;
     }
-  }
-  else
+  } else
     result = processStream(filename, parser);
   return result;
 }
diff --git a/contrib/expat/xmlwf/xmlfile.h b/contrib/expat/xmlwf/xmlfile.h
index c47ea2cf5947..6e5d5b49eb78 100644
--- a/contrib/expat/xmlwf/xmlfile.h
+++ b/contrib/expat/xmlwf/xmlfile.h
@@ -34,15 +34,10 @@
 #define XML_EXTERNAL_ENTITIES 02
 
 #ifdef XML_LARGE_SIZE
-#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
-#define XML_FMT_INT_MOD "I64"
+#  define XML_FMT_INT_MOD "ll"
 #else
-#define XML_FMT_INT_MOD "ll"
-#endif
-#else
-#define XML_FMT_INT_MOD "l"
+#  define XML_FMT_INT_MOD "l"
 #endif
 
-extern int XML_ProcessFile(XML_Parser parser,
-                           const XML_Char *filename,
+extern int XML_ProcessFile(XML_Parser parser, const XML_Char *filename,
                            unsigned flags);
diff --git a/contrib/expat/xmlwf/xmlmime.c b/contrib/expat/xmlwf/xmlmime.c
index c530979060f4..39160d7198ce 100644
--- a/contrib/expat/xmlwf/xmlmime.c
+++ b/contrib/expat/xmlwf/xmlmime.c
@@ -34,8 +34,7 @@
 #include "xmlmime.h"
 
 static const char *
-getTok(const char **pp)
-{
+getTok(const char **pp) {
   /* inComment means one level of nesting; inComment+1 means two levels etc */
   enum { inAtom, inString, init, inComment };
   int state = init;
@@ -106,9 +105,8 @@ getTok(const char **pp)
 /* key must be lowercase ASCII */
 
 static int
-matchkey(const char *start, const char *end, const char *key)
-{
-  if (!start)
+matchkey(const char *start, const char *end, const char *key) {
+  if (! start)
     return 0;
   for (; start != end; start++, key++)
     if (*start != *key && *start != 'A' + (*key - 'a'))
@@ -117,8 +115,7 @@ matchkey(const char *start, const char *end, const char *key)
 }
 
 void
-getXMLCharset(const char *buf, char *charset)
-{
+getXMLCharset(const char *buf, char *charset) {
   const char *next, *p;
 
   charset[0] = '\0';
@@ -126,16 +123,18 @@ getXMLCharset(const char *buf, char *charset)
   p = getTok(&next);
   if (matchkey(p, next, "text"))
     strcpy(charset, "us-ascii");
-  else if (!matchkey(p, next, "application"))
+  else if (! matchkey(p, next, "application"))
     return;
   p = getTok(&next);
-  if (!p || *p != '/')
+  if (! p || *p != '/')
     return;
   p = getTok(&next);
-#if 0
-  if (!matchkey(p, next, "xml") && charset[0] == '\0')
-    return;
-#endif
+  /* BEGIN disabled code */
+  if (0) {
+    if (! matchkey(p, next, "xml") && charset[0] == '\0')
+      return;
+  }
+  /* END disabled code */
   p = getTok(&next);
   while (p) {
     if (*p == ';') {
@@ -157,8 +156,7 @@ getXMLCharset(const char *buf, char *charset)
                 *s++ = *p;
               }
               *s++ = '\0';
-            }
-            else {
+            } else {
               if (next - p > CHARSET_MAX - 1)
                 break;
               while (p != next)
@@ -170,19 +168,17 @@ getXMLCharset(const char *buf, char *charset)
         }
         break;
       }
-    }
-  else
-    p = getTok(&next);
+    } else
+      p = getTok(&next);
   }
 }
 
 #ifdef TEST
 
-#include <stdio.h>
+#  include <stdio.h>
 
 int
-main(int argc, char *argv[])
-{
+main(int argc, char *argv[]) {
   char buf[CHARSET_MAX];
   if (argc <= 1)
     return 1;
diff --git a/contrib/expat/xmlwf/xmltchar.h b/contrib/expat/xmlwf/xmltchar.h
index cdfaea79552f..d7e7b411b44b 100644
--- a/contrib/expat/xmlwf/xmltchar.h
+++ b/contrib/expat/xmlwf/xmltchar.h
@@ -34,41 +34,41 @@
 #include "expat_external.h"
 
 #ifdef XML_UNICODE
-# ifndef XML_UNICODE_WCHAR_T
-#  error xmlwf requires a 16-bit Unicode-compatible wchar_t
-# endif
-# define _PREPEND_BIG_L(x) L ## x
-# define T(x) _PREPEND_BIG_L(x)
-# define ftprintf fwprintf
-# define tfopen _wfopen
-# define fputts fputws
-# define puttc putwc
-# define tcscmp wcscmp
-# define tcscpy wcscpy
-# define tcscat wcscat
-# define tcschr wcschr
-# define tcsrchr wcsrchr
-# define tcslen wcslen
-# define tperror _wperror
-# define topen _wopen
-# define tmain wmain
-# define tremove _wremove
-# define tchar wchar_t
+#  ifndef XML_UNICODE_WCHAR_T
+#    error xmlwf requires a 16-bit Unicode-compatible wchar_t
+#  endif
+#  define _PREPEND_BIG_L(x) L##x
+#  define T(x) _PREPEND_BIG_L(x)
+#  define ftprintf fwprintf
+#  define tfopen _wfopen
+#  define fputts fputws
+#  define puttc putwc
+#  define tcscmp wcscmp
+#  define tcscpy wcscpy
+#  define tcscat wcscat
+#  define tcschr wcschr
+#  define tcsrchr wcsrchr
+#  define tcslen wcslen
+#  define tperror _wperror
+#  define topen _wopen
+#  define tmain wmain
+#  define tremove _wremove
+#  define tchar wchar_t
 #else /* not XML_UNICODE */
-# define T(x) x
-# define ftprintf fprintf
-# define tfopen fopen
-# define fputts fputs
-# define puttc putc
-# define tcscmp strcmp
-# define tcscpy strcpy
-# define tcscat strcat
-# define tcschr strchr
-# define tcsrchr strrchr
-# define tcslen strlen
-# define tperror perror
-# define topen open
-# define tmain main
-# define tremove remove
-# define tchar char
+#  define T(x) x
+#  define ftprintf fprintf
+#  define tfopen fopen
+#  define fputts fputs
+#  define puttc putc
+#  define tcscmp strcmp
+#  define tcscpy strcpy
+#  define tcscat strcat
+#  define tcschr strchr
+#  define tcsrchr strrchr
+#  define tcslen strlen
+#  define tperror perror
+#  define topen open
+#  define tmain main
+#  define tremove remove
+#  define tchar char
 #endif /* not XML_UNICODE */
diff --git a/contrib/expat/xmlwf/xmlwf.c b/contrib/expat/xmlwf/xmlwf.c
index 82d028ea56fd..2d5a87e7d99d 100644
--- a/contrib/expat/xmlwf/xmlwf.c
+++ b/contrib/expat/xmlwf/xmlwf.c
@@ -38,16 +38,16 @@
 
 #include "expat.h"
 #include "codepage.h"
-#include "internal.h"  /* for UNUSED_P only */
+#include "internal.h" /* for UNUSED_P only */
 #include "xmlfile.h"
 #include "xmltchar.h"
 
 #ifdef _MSC_VER
-# include <crtdbg.h>
+#  include <crtdbg.h>
 #endif
 
 #ifdef XML_UNICODE
-# include <wchar.h>
+#  include <wchar.h>
 #endif
 
 /* Structures for handler user data */
@@ -64,14 +64,12 @@ typedef struct xmlwfUserData {
   const XML_Char *currentDoctypeName;
 } XmlwfUserData;
 
-
 /* This ensures proper sorting. */
 
 #define NSSEP T('\001')
 
 static void XMLCALL
-characterData(void *userData, const XML_Char *s, int len)
-{
+characterData(void *userData, const XML_Char *s, int len) {
   FILE *fp = ((XmlwfUserData *)userData)->fp;
   for (; len > 0; --len, ++s) {
     switch (*s) {
@@ -106,8 +104,7 @@ characterData(void *userData, const XML_Char *s, int len)
 }
 
 static void
-attributeValue(FILE *fp, const XML_Char *s)
-{
+attributeValue(FILE *fp, const XML_Char *s) {
   puttc(T('='), fp);
   puttc(T('"'), fp);
   assert(s);
@@ -158,14 +155,12 @@ attributeValue(FILE *fp, const XML_Char *s)
 is equivalent to lexicographically comparing based on the character number. */
 
 static int
-attcmp(const void *att1, const void *att2)
-{
+attcmp(const void *att1, const void *att2) {
   return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
 }
 
 static void XMLCALL
-startElement(void *userData, const XML_Char *name, const XML_Char **atts)
-{
+startElement(void *userData, const XML_Char *name, const XML_Char **atts) {
   int nAtts;
   const XML_Char **p;
   FILE *fp = ((XmlwfUserData *)userData)->fp;
@@ -188,8 +183,7 @@ startElement(void *userData, const XML_Char *name, const XML_Char **atts)
 }
 
 static void XMLCALL
-endElement(void *userData, const XML_Char *name)
-{
+endElement(void *userData, const XML_Char *name) {
   FILE *fp = ((XmlwfUserData *)userData)->fp;
   puttc(T('<'), fp);
   puttc(T('/'), fp);
@@ -198,8 +192,7 @@ endElement(void *userData, const XML_Char *name)
 }
 
 static int
-nsattcmp(const void *p1, const void *p2)
-{
+nsattcmp(const void *p1, const void *p2) {
   const XML_Char *att1 = *(const XML_Char **)p1;
   const XML_Char *att2 = *(const XML_Char **)p2;
   int sep1 = (tcsrchr(att1, NSSEP) != 0);
@@ -210,8 +203,7 @@ nsattcmp(const void *p1, const void *p2)
 }
 
 static void XMLCALL
-startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
-{
+startElementNS(void *userData, const XML_Char *name, const XML_Char **atts) {
   int nAtts;
   int nsi;
   const XML_Char **p;
@@ -226,8 +218,7 @@ startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
     fputts(T(" xmlns:n1"), fp);
     attributeValue(fp, name);
     nsi = 2;
-  }
-  else {
+  } else {
     fputts(name, fp);
     nsi = 1;
   }
@@ -245,8 +236,7 @@ startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
     if (sep) {
       ftprintf(fp, T("n%d:"), nsi);
       fputts(sep + 1, fp);
-    }
-    else
+    } else
       fputts(name, fp);
     attributeValue(fp, *atts);
     if (sep) {
@@ -259,8 +249,7 @@ startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
 }
 
 static void XMLCALL
-endElementNS(void *userData, const XML_Char *name)
-{
+endElementNS(void *userData, const XML_Char *name) {
   FILE *fp = ((XmlwfUserData *)userData)->fp;
   const XML_Char *sep;
   puttc(T('<'), fp);
@@ -269,8 +258,7 @@ endElementNS(void *userData, const XML_Char *name)
   if (sep) {
     fputts(T("n1:"), fp);
     fputts(sep + 1, fp);
-  }
-  else
+  } else
     fputts(name, fp);
   puttc(T('>'), fp);
 }
@@ -279,8 +267,7 @@ endElementNS(void *userData, const XML_Char *name)
 
 static void XMLCALL
 processingInstruction(void *userData, const XML_Char *target,
-                      const XML_Char *data)
-{
+                      const XML_Char *data) {
   FILE *fp = ((XmlwfUserData *)userData)->fp;
   puttc(T('<'), fp);
   puttc(T('?'), fp);
@@ -291,9 +278,8 @@ processingInstruction(void *userData, const XML_Char *target,
   puttc(T('>'), fp);
 }
 
-
-static XML_Char *xcsdup(const XML_Char *s)
-{
+static XML_Char *
+xcsdup(const XML_Char *s) {
   XML_Char *result;
   int count = 0;
   int numBytes;
@@ -311,19 +297,18 @@ static XML_Char *xcsdup(const XML_Char *s)
 }
 
 static void XMLCALL
-startDoctypeDecl(void *userData,
-                 const XML_Char *doctypeName,
-                 const XML_Char *UNUSED_P(sysid),
-                 const XML_Char *UNUSED_P(publid),
-                 int UNUSED_P(has_internal_subset))
-{
+startDoctypeDecl(void *userData, const XML_Char *doctypeName,
+                 const XML_Char *sysid, const XML_Char *publid,
+                 int has_internal_subset) {
   XmlwfUserData *data = (XmlwfUserData *)userData;
+  UNUSED_P(sysid);
+  UNUSED_P(publid);
+  UNUSED_P(has_internal_subset);
   data->currentDoctypeName = xcsdup(doctypeName);
 }
 
 static void
-freeNotations(XmlwfUserData *data)
-{
+freeNotations(XmlwfUserData *data) {
   NotationList *notationListHead = data->notationListHead;
 
   while (notationListHead != NULL) {
@@ -337,8 +322,8 @@ freeNotations(XmlwfUserData *data)
   data->notationListHead = NULL;
 }
 
-static int xcscmp(const XML_Char *xs, const XML_Char *xt)
-{
+static int
+xcscmp(const XML_Char *xs, const XML_Char *xt) {
   while (*xs != 0 && *xt != 0) {
     if (*xs < *xt)
       return -1;
@@ -355,17 +340,15 @@ static int xcscmp(const XML_Char *xs, const XML_Char *xt)
 }
 
 static int
-notationCmp(const void *a, const void *b)
-{
-  const NotationList * const n1 = *(NotationList **)a;
-  const NotationList * const n2 = *(NotationList **)b;
+notationCmp(const void *a, const void *b) {
+  const NotationList *const n1 = *(NotationList **)a;
+  const NotationList *const n2 = *(NotationList **)b;
 
   return xcscmp(n1->notationName, n2->notationName);
 }
 
 static void XMLCALL
-endDoctypeDecl(void *userData)
-{
+endDoctypeDecl(void *userData) {
   XmlwfUserData *data = (XmlwfUserData *)userData;
   NotationList **notations;
   int notationCount = 0;
@@ -389,9 +372,7 @@ endDoctypeDecl(void *userData)
     return;
   }
 
-  for (p = data->notationListHead, i = 0;
-       i < notationCount;
-       p = p->next, i++) {
+  for (p = data->notationListHead, i = 0; i < notationCount; p = p->next, i++) {
     notations[i] = p;
   }
   qsort(notations, notationCount, sizeof(NotationList *), notationCmp);
@@ -415,8 +396,7 @@ endDoctypeDecl(void *userData)
         fputts(notations[i]->systemId, data->fp);
         puttc(T('\''), data->fp);
       }
-    }
-    else if (notations[i]->systemId != NULL) {
+    } else if (notations[i]->systemId != NULL) {
       fputts(T(" SYSTEM '"), data->fp);
       fputts(notations[i]->systemId, data->fp);
       puttc(T('\''), data->fp);
@@ -435,16 +415,13 @@ endDoctypeDecl(void *userData)
 }
 
 static void XMLCALL
-notationDecl(void *userData,
-             const XML_Char *notationName,
-             const XML_Char *UNUSED_P(base),
-             const XML_Char *systemId,
-             const XML_Char *publicId)
-{
+notationDecl(void *userData, const XML_Char *notationName, const XML_Char *base,
+             const XML_Char *systemId, const XML_Char *publicId) {
   XmlwfUserData *data = (XmlwfUserData *)userData;
   NotationList *entry = malloc(sizeof(NotationList));
   const char *errorMessage = "Unable to store NOTATION for output\n";
 
+  UNUSED_P(base);
   if (entry == NULL) {
     fputs(errorMessage, stderr);
     return; /* Nothing we can really do about this */
@@ -463,8 +440,7 @@ notationDecl(void *userData,
       free(entry);
       return;
     }
-  }
-  else {
+  } else {
     entry->systemId = NULL;
   }
   if (publicId != NULL) {
@@ -476,8 +452,7 @@ notationDecl(void *userData,
       free(entry);
       return;
     }
-  }
-  else {
+  } else {
     entry->publicId = NULL;
   }
 
@@ -488,101 +463,103 @@ notationDecl(void *userData,
 #endif /* not W3C14N */
 
 static void XMLCALL
-defaultCharacterData(void *userData, const XML_Char *UNUSED_P(s), int UNUSED_P(len))
-{
-  XML_DefaultCurrent((XML_Parser) userData);
+defaultCharacterData(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(s);
+  UNUSED_P(len);
+  XML_DefaultCurrent((XML_Parser)userData);
 }
 
 static void XMLCALL
-defaultStartElement(void *userData, const XML_Char *UNUSED_P(name),
-                    const XML_Char **UNUSED_P(atts))
-{
-  XML_DefaultCurrent((XML_Parser) userData);
+defaultStartElement(void *userData, const XML_Char *name,
+                    const XML_Char **atts) {
+  UNUSED_P(name);
+  UNUSED_P(atts);
+  XML_DefaultCurrent((XML_Parser)userData);
 }
 
 static void XMLCALL
-defaultEndElement(void *userData, const XML_Char *UNUSED_P(name))
-{
-  XML_DefaultCurrent((XML_Parser) userData);
+defaultEndElement(void *userData, const XML_Char *name) {
+  UNUSED_P(name);
+  XML_DefaultCurrent((XML_Parser)userData);
 }
 
 static void XMLCALL
-defaultProcessingInstruction(void *userData, const XML_Char *UNUSED_P(target),
-                             const XML_Char *UNUSED_P(data))
-{
-  XML_DefaultCurrent((XML_Parser) userData);
+defaultProcessingInstruction(void *userData, const XML_Char *target,
+                             const XML_Char *data) {
+  UNUSED_P(target);
+  UNUSED_P(data);
+  XML_DefaultCurrent((XML_Parser)userData);
 }
 
 static void XMLCALL
-nopCharacterData(void *UNUSED_P(userData), const XML_Char *UNUSED_P(s), int UNUSED_P(len))
-{
+nopCharacterData(void *userData, const XML_Char *s, int len) {
+  UNUSED_P(userData);
+  UNUSED_P(s);
+  UNUSED_P(len);
 }
 
 static void XMLCALL
-nopStartElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name), const XML_Char **UNUSED_P(atts))
-{
+nopStartElement(void *userData, const XML_Char *name, const XML_Char **atts) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
+  UNUSED_P(atts);
 }
 
 static void XMLCALL
-nopEndElement(void *UNUSED_P(userData), const XML_Char *UNUSED_P(name))
-{
+nopEndElement(void *userData, const XML_Char *name) {
+  UNUSED_P(userData);
+  UNUSED_P(name);
 }
 
 static void XMLCALL
-nopProcessingInstruction(void *UNUSED_P(userData), const XML_Char *UNUSED_P(target),
-                         const XML_Char *UNUSED_P(data))
-{
+nopProcessingInstruction(void *userData, const XML_Char *target,
+                         const XML_Char *data) {
+  UNUSED_P(userData);
+  UNUSED_P(target);
+  UNUSED_P(data);
 }
 
 static void XMLCALL
-markup(void *userData, const XML_Char *s, int len)
-{
-  FILE *fp = ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp;
+markup(void *userData, const XML_Char *s, int len) {
+  FILE *fp = ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp;
   for (; len > 0; --len, ++s)
     puttc(*s, fp);
 }
 
 static void
-metaLocation(XML_Parser parser)
-{
+metaLocation(XML_Parser parser) {
   const XML_Char *uri = XML_GetBase(parser);
   FILE *fp = ((XmlwfUserData *)XML_GetUserData(parser))->fp;
   if (uri)
     ftprintf(fp, T(" uri=\"%s\""), uri);
   ftprintf(fp,
-           T(" byte=\"%") T(XML_FMT_INT_MOD) T("d\"")
-             T(" nbytes=\"%d\"")
-             T(" line=\"%") T(XML_FMT_INT_MOD) T("u\"")
-             T(" col=\"%") T(XML_FMT_INT_MOD) T("u\""),
-           XML_GetCurrentByteIndex(parser),
-           XML_GetCurrentByteCount(parser),
+           T(" byte=\"%") T(XML_FMT_INT_MOD) T("d\"") T(" nbytes=\"%d\"")
+               T(" line=\"%") T(XML_FMT_INT_MOD) T("u\"") T(" col=\"%")
+                   T(XML_FMT_INT_MOD) T("u\""),
+           XML_GetCurrentByteIndex(parser), XML_GetCurrentByteCount(parser),
            XML_GetCurrentLineNumber(parser),
            XML_GetCurrentColumnNumber(parser));
 }
 
 static void
-metaStartDocument(void *userData)
-{
+metaStartDocument(void *userData) {
   fputts(T("<document>\n"),
-         ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
+         ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp);
 }
 
 static void
-metaEndDocument(void *userData)
-{
+metaEndDocument(void *userData) {
   fputts(T("</document>\n"),
-         ((XmlwfUserData *)XML_GetUserData((XML_Parser) userData))->fp);
+         ((XmlwfUserData *)XML_GetUserData((XML_Parser)userData))->fp);
 }
 
 static void XMLCALL
-metaStartElement(void *userData, const XML_Char *name,
-                 const XML_Char **atts)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaStartElement(void *userData, const XML_Char *name, const XML_Char **atts) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   const XML_Char **specifiedAttsEnd
-    = atts + XML_GetSpecifiedAttributeCount(parser);
+      = atts + XML_GetSpecifiedAttributeCount(parser);
   const XML_Char **idAttPtr;
   int idAttIndex = XML_GetIdAttributeIndex(parser);
   if (idAttIndex < 0)
@@ -605,15 +582,13 @@ metaStartElement(void *userData, const XML_Char *name,
         fputts(T("\"/>\n"), fp);
     } while (*(atts += 2));
     fputts(T("</starttag>\n"), fp);
-  }
-  else
+  } else
     fputts(T("/>\n"), fp);
 }
 
 static void XMLCALL
-metaEndElement(void *userData, const XML_Char *name)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaEndElement(void *userData, const XML_Char *name) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   ftprintf(fp, T("<endtag name=\"%s\""), name);
@@ -623,9 +598,8 @@ metaEndElement(void *userData, const XML_Char *name)
 
 static void XMLCALL
 metaProcessingInstruction(void *userData, const XML_Char *target,
-                          const XML_Char *data)
-{
-  XML_Parser parser = (XML_Parser) userData;
+                          const XML_Char *data) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = usrData->fp;
   ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
@@ -636,9 +610,8 @@ metaProcessingInstruction(void *userData, const XML_Char *target,
 }
 
 static void XMLCALL
-metaComment(void *userData, const XML_Char *data)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaComment(void *userData, const XML_Char *data) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *usrData = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = usrData->fp;
   fputts(T("<comment data=\""), fp);
@@ -649,9 +622,8 @@ metaComment(void *userData, const XML_Char *data)
 }
 
 static void XMLCALL
-metaStartCdataSection(void *userData)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaStartCdataSection(void *userData) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   fputts(T("<startcdata"), fp);
@@ -660,9 +632,8 @@ metaStartCdataSection(void *userData)
 }
 
 static void XMLCALL
-metaEndCdataSection(void *userData)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaEndCdataSection(void *userData) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   fputts(T("<endcdata"), fp);
@@ -671,9 +642,8 @@ metaEndCdataSection(void *userData)
 }
 
 static void XMLCALL
-metaCharacterData(void *userData, const XML_Char *s, int len)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaCharacterData(void *userData, const XML_Char *s, int len) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   fputts(T("<chars str=\""), fp);
@@ -684,24 +654,23 @@ metaCharacterData(void *userData, const XML_Char *s, int len)
 }
 
 static void XMLCALL
-metaStartDoctypeDecl(void *userData,
-                     const XML_Char *doctypeName,
-                     const XML_Char *UNUSED_P(sysid),
-                     const XML_Char *UNUSED_P(pubid),
-                     int UNUSED_P(has_internal_subset))
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaStartDoctypeDecl(void *userData, const XML_Char *doctypeName,
+                     const XML_Char *sysid, const XML_Char *pubid,
+                     int has_internal_subset) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
+  UNUSED_P(sysid);
+  UNUSED_P(pubid);
+  UNUSED_P(has_internal_subset);
   ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 static void XMLCALL
-metaEndDoctypeDecl(void *userData)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaEndDoctypeDecl(void *userData) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   fputts(T("<enddoctype"), fp);
@@ -710,15 +679,13 @@ metaEndDoctypeDecl(void *userData)
 }
 
 static void XMLCALL
-metaNotationDecl(void *userData,
-                 const XML_Char *notationName,
-                 const XML_Char *UNUSED_P(base),
-                 const XML_Char *systemId,
-                 const XML_Char *publicId)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaNotationDecl(void *userData, const XML_Char *notationName,
+                 const XML_Char *base, const XML_Char *systemId,
+                 const XML_Char *publicId) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
+  UNUSED_P(base);
   ftprintf(fp, T("<notation name=\"%s\""), notationName);
   if (publicId)
     ftprintf(fp, T(" public=\"%s\""), publicId);
@@ -731,30 +698,24 @@ metaNotationDecl(void *userData,
   fputts(T("/>\n"), fp);
 }
 
-
 static void XMLCALL
-metaEntityDecl(void *userData,
-               const XML_Char *entityName,
-               int  UNUSED_P(is_param),
-               const XML_Char *value,
-               int  value_length,
-               const XML_Char *UNUSED_P(base),
-               const XML_Char *systemId,
-               const XML_Char *publicId,
-               const XML_Char *notationName)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaEntityDecl(void *userData, const XML_Char *entityName, int is_param,
+               const XML_Char *value, int value_length, const XML_Char *base,
+               const XML_Char *systemId, const XML_Char *publicId,
+               const XML_Char *notationName) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
 
+  UNUSED_P(is_param);
+  UNUSED_P(base);
   if (value) {
     ftprintf(fp, T("<entity name=\"%s\""), entityName);
     metaLocation(parser);
     puttc(T('>'), fp);
     characterData(data, value, value_length);
     fputts(T("</entity/>\n"), fp);
-  }
-  else if (notationName) {
+  } else if (notationName) {
     ftprintf(fp, T("<entity name=\"%s\""), entityName);
     if (publicId)
       ftprintf(fp, T(" public=\"%s\""), publicId);
@@ -764,8 +725,7 @@ metaEntityDecl(void *userData,
     ftprintf(fp, T(" notation=\"%s\""), notationName);
     metaLocation(parser);
     fputts(T("/>\n"), fp);
-  }
-  else {
+  } else {
     ftprintf(fp, T("<entity name=\"%s\""), entityName);
     if (publicId)
       ftprintf(fp, T(" public=\"%s\""), publicId);
@@ -778,11 +738,9 @@ metaEntityDecl(void *userData,
 }
 
 static void XMLCALL
-metaStartNamespaceDecl(void *userData,
-                       const XML_Char *prefix,
-                       const XML_Char *uri)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaStartNamespaceDecl(void *userData, const XML_Char *prefix,
+                       const XML_Char *uri) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
   fputts(T("<startns"), fp);
@@ -792,74 +750,70 @@ metaStartNamespaceDecl(void *userData,
     fputts(T(" ns=\""), fp);
     characterData(data, uri, (int)tcslen(uri));
     fputts(T("\"/>\n"), fp);
-  }
-  else
+  } else
     fputts(T("/>\n"), fp);
 }
 
 static void XMLCALL
-metaEndNamespaceDecl(void *userData, const XML_Char *prefix)
-{
-  XML_Parser parser = (XML_Parser) userData;
+metaEndNamespaceDecl(void *userData, const XML_Char *prefix) {
+  XML_Parser parser = (XML_Parser)userData;
   XmlwfUserData *data = (XmlwfUserData *)XML_GetUserData(parser);
   FILE *fp = data->fp;
-  if (!prefix)
+  if (! prefix)
     fputts(T("<endns/>\n"), fp);
   else
     ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
 }
 
 static int XMLCALL
-unknownEncodingConvert(void *data, const char *p)
-{
+unknownEncodingConvert(void *data, const char *p) {
   return codepageConvert(*(int *)data, p);
 }
 
 static int XMLCALL
-unknownEncoding(void *UNUSED_P(userData), const XML_Char *name, XML_Encoding *info)
-{
+unknownEncoding(void *userData, const XML_Char *name, XML_Encoding *info) {
   int cp;
   static const XML_Char prefixL[] = T("windows-");
   static const XML_Char prefixU[] = T("WINDOWS-");
   int i;
 
+  UNUSED_P(userData);
   for (i = 0; prefixU[i]; i++)
     if (name[i] != prefixU[i] && name[i] != prefixL[i])
       return 0;
-  
+
   cp = 0;
   for (; name[i]; i++) {
     static const XML_Char digits[] = T("0123456789");
     const XML_Char *s = tcschr(digits, name[i]);
-    if (!s)
+    if (! s)
       return 0;
     cp *= 10;
     cp += (int)(s - digits);
     if (cp >= 0x10000)
       return 0;
   }
-  if (!codepageMap(cp, info->map))
+  if (! codepageMap(cp, info->map))
     return 0;
   info->convert = unknownEncodingConvert;
   /* We could just cast the code page integer to a void *,
   and avoid the use of release. */
   info->release = free;
   info->data = malloc(sizeof(int));
-  if (!info->data)
+  if (! info->data)
     return 0;
   *(int *)info->data = cp;
   return 1;
 }
 
 static int XMLCALL
-notStandalone(void *UNUSED_P(userData))
-{
+notStandalone(void *userData) {
+  UNUSED_P(userData);
   return 0;
 }
 
 static void
-showVersion(XML_Char *prog)
-{
+showVersion(XML_Char *prog) {
   XML_Char *s = prog;
   XML_Char ch;
   const XML_Feature *features = XML_GetFeatureList();
@@ -868,7 +822,7 @@ showVersion(XML_Char *prog)
 #if defined(_WIN32)
         || ch == '\\'
 #endif
-        )
+    )
       prog = s + 1;
     ++s;
   }
@@ -889,10 +843,46 @@ showVersion(XML_Char *prog)
 }
 
 static void
-usage(const XML_Char *prog, int rc)
-{
-  ftprintf(stderr,
-           T("usage: %s [-s] [-n] [-p] [-x] [-e encoding] [-w] [-d output-dir] [-c] [-m] [-r] [-t] [-N] [file ...]\n"), prog);
+usage(const XML_Char *prog, int rc) {
+  ftprintf(
+      stderr,
+      /* Generated with:
+       * $ xmlwf/xmlwf_helpgen.sh
+       */
+      /* clang-format off */
+      T("usage: %s [-s] [-n] [-p] [-x] [-e ENCODING] [-w] [-r] [-d DIRECTORY]\n")
+      T("             [-c | -m | -t] [-N]\n")
+      T("             [FILE [FILE ...]]\n")
+      T("\n")
+      T("xmlwf - Determines if an XML document is well-formed\n")
+      T("\n")
+      T("positional arguments:\n")
+      T("  FILE          files to process (default: STDIN)\n")
+      T("\n")
+      T("input control arguments:\n")
+      T("  -s            print an error if the document is not [s]tandalone\n")
+      T("  -n            enable [n]amespace processing\n")
+      T("  -p            enable processing external DTDs and [p]arameter entities\n")
+      T("  -x            enable processing of e[x]ternal entities\n")
+      T("  -e ENCODING   override any in-document [e]ncoding declaration\n")
+      T("  -w            enable support for [W]indows code pages\n")
+      T("  -r            disable memory-mapping and use normal file [r]ead IO calls instead\n")
+      T("\n")
+      T("output control arguments:\n")
+      T("  -d DIRECTORY  output [d]estination directory\n")
+      T("  -c            write a [c]opy of input XML, not canonical XML\n")
+      T("  -m            write [m]eta XML, not canonical XML\n")
+      T("  -t            write no XML output for [t]iming of plain parsing\n")
+      T("  -N            enable adding doctype and [n]otation declarations\n")
+      T("\n")
+      T("info arguments:\n")
+      T("  -h            show this [h]elp message and exit\n")
+      T("  -v            show program's [v]ersion number and exit\n")
+      T("\n")
+      T("libexpat is software libre, licensed under the MIT license.\n")
+      T("Please report bugs at https://github.com/libexpat/libexpat/issues.  Thank you!\n")
+      , /* clang-format on */
+      prog);
   exit(rc);
 }
 
@@ -902,8 +892,7 @@ int wmain(int argc, XML_Char **argv);
 #endif
 
 int
-tmain(int argc, XML_Char **argv)
-{
+tmain(int argc, XML_Char **argv) {
   int i, j;
   const XML_Char *outputDir = NULL;
   const XML_Char *encoding = NULL;
@@ -913,13 +902,13 @@ tmain(int argc, XML_Char **argv)
   int useNamespaces = 0;
   int requireStandalone = 0;
   int requiresNotations = 0;
-  enum XML_ParamEntityParsing paramEntityParsing = 
-    XML_PARAM_ENTITY_PARSING_NEVER;
+  enum XML_ParamEntityParsing paramEntityParsing
+      = XML_PARAM_ENTITY_PARSING_NEVER;
   int useStdin = 0;
-  XmlwfUserData userData = { NULL, NULL, NULL };
+  XmlwfUserData userData = {NULL, NULL, NULL};
 
 #ifdef _MSC_VER
-  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
+  _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
 #endif
 
   i = 1;
@@ -980,8 +969,7 @@ tmain(int argc, XML_Char **argv)
         if (++i == argc)
           usage(argv[0], 2);
         outputDir = argv[i];
-      }
-      else
+      } else
         outputDir = argv[i] + j + 1;
       i++;
       j = 0;
@@ -991,8 +979,7 @@ tmain(int argc, XML_Char **argv)
         if (++i == argc)
           usage(argv[0], 2);
         encoding = argv[i];
-      }
-      else
+      } else
         encoding = argv[i] + j + 1;
       i++;
       j = 0;
@@ -1043,18 +1030,17 @@ tmain(int argc, XML_Char **argv)
       XML_SetElementHandler(parser, nopStartElement, nopEndElement);
       XML_SetCharacterDataHandler(parser, nopCharacterData);
       XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
-    }
-    else if (outputDir) {
-      const XML_Char * delim = T("/");
+    } else if (outputDir) {
+      const XML_Char *delim = T("/");
       const XML_Char *file = useStdin ? T("STDIN") : argv[i];
-      if (!useStdin) {
+      if (! useStdin) {
         /* Jump after last (back)slash */
-        const XML_Char * lastDelim = tcsrchr(file, delim[0]);
+        const XML_Char *lastDelim = tcsrchr(file, delim[0]);
         if (lastDelim)
           file = lastDelim + 1;
 #if defined(_WIN32)
         else {
-          const XML_Char * winDelim = T("\\");
+          const XML_Char *winDelim = T("\\");
           lastDelim = tcsrchr(file, winDelim[0]);
           if (lastDelim) {
             file = lastDelim + 1;
@@ -1064,12 +1050,12 @@ tmain(int argc, XML_Char **argv)
 #endif
       }
       outName = (XML_Char *)malloc((tcslen(outputDir) + tcslen(file) + 2)
-                       * sizeof(XML_Char));
+                                   * sizeof(XML_Char));
       tcscpy(outName, outputDir);
       tcscat(outName, delim);
       tcscat(outName, file);
       userData.fp = tfopen(outName, T("wb"));
-      if (!userData.fp) {
+      if (! userData.fp) {
         tperror(outName);
         exit(1);
       }
@@ -1126,13 +1112,15 @@ tmain(int argc, XML_Char **argv)
       if (outputType == 'm')
         metaEndDocument(parser);
       fclose(userData.fp);
-      if (!result) {
+      if (! result) {
         tremove(outName);
-        exit(2);
       }
       free(outName);
     }
     XML_ParserFree(parser);
+    if (! result) {
+      exit(2);
+    }
   }
   return 0;
 }
diff --git a/contrib/expat/xmlwf/xmlwf_helpgen.py b/contrib/expat/xmlwf/xmlwf_helpgen.py
new file mode 100755
index 000000000000..0dcb6d34e37c
--- /dev/null
+++ b/contrib/expat/xmlwf/xmlwf_helpgen.py
@@ -0,0 +1,69 @@
+#! /usr/bin/env python3
+#                          __  __            _
+#                       ___\ \/ /_ __   __ _| |_
+#                      / _ \\  /| '_ \ / _` | __|
+#                     |  __//  \| |_) | (_| | |_
+#                      \___/_/\_\ .__/ \__,_|\__|
+#                               |_| XML parser
+#
+# Copyright (c) 2019 Expat development team
+# Licensed under the MIT license:
+#
+# 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  furnished 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, FITNESS 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.
+
+import argparse
+
+epilog = """
+libexpat is software libre, licensed under the MIT license.
+Please report bugs at https://github.com/libexpat/libexpat/issues.  Thank you!
+"""
+
+parser = argparse.ArgumentParser(prog='xmlwf', add_help=False,
+                                 description='xmlwf - Determines if an XML document is well-formed',
+                                 formatter_class=argparse.RawTextHelpFormatter,
+                                 epilog=epilog)
+
+input_related = parser.add_argument_group('input control arguments')
+input_related.add_argument('-s', action='store_true', help='print an error if the document is not [s]tandalone')
+input_related.add_argument('-n', action='store_true', help='enable [n]amespace processing')
+input_related.add_argument('-p', action='store_true', help='enable processing external DTDs and [p]arameter entities')
+input_related.add_argument('-x', action='store_true', help='enable processing of e[x]ternal entities')
+input_related.add_argument('-e', action='store', metavar='ENCODING', help='override any in-document [e]ncoding declaration')
+input_related.add_argument('-w', action='store_true', help='enable support for [W]indows code pages')
+input_related.add_argument('-r', action='store_true', help='disable memory-mapping and use normal file [r]ead IO calls instead')
+
+output_related = parser.add_argument_group('output control arguments')
+output_related.add_argument('-d', action='store', metavar='DIRECTORY', help='output [d]estination directory')
+output_mode = output_related.add_mutually_exclusive_group()
+output_mode.add_argument('-c', action='store_true', help='write a [c]opy of input XML, not canonical XML')
+output_mode.add_argument('-m', action='store_true', help='write [m]eta XML, not canonical XML')
+output_mode.add_argument('-t', action='store_true', help='write no XML output for [t]iming of plain parsing')
+output_related.add_argument('-N', action='store_true', help='enable adding doctype and [n]otation declarations')
+
+parser.add_argument('files', metavar='FILE', nargs='*', help='files to process (default: STDIN)')
+
+info = parser.add_argument_group('info arguments')
+info = info.add_mutually_exclusive_group()
+info.add_argument('-h', action='store_true', help='show this [h]elp message and exit')
+info.add_argument('-v', action='store_true', help='show program\'s [v]ersion number and exit')
+
+
+if __name__ == '__main__':
+    parser.print_help()
diff --git a/contrib/expat/xmlwf/xmlwf_helpgen.sh b/contrib/expat/xmlwf/xmlwf_helpgen.sh
new file mode 100755
index 000000000000..6b0fbf929a09
--- /dev/null
+++ b/contrib/expat/xmlwf/xmlwf_helpgen.sh
@@ -0,0 +1,35 @@
+#! /usr/bin/env bash
+#                          __  __            _
+#                       ___\ \/ /_ __   __ _| |_
+#                      / _ \\  /| '_ \ / _` | __|
+#                     |  __//  \| |_) | (_| | |_
+#                      \___/_/\_\ .__/ \__,_|\__|
+#                               |_| XML parser
+#
+# Copyright (c) 2019 Expat development team
+# Licensed under the MIT license:
+#
+# 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  furnished 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, FITNESS 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.
+
+./xmlwf/xmlwf_helpgen.py | sed \
+        -e 's,usage: xmlwf,usage: %s,' \
+        -e 's, \[-h | -v\],,' \
+        -e 's,^,      T(",' \
+        -e 's,$,\\n"),'
author	Xin LI <delphij@FreeBSD.org>	2019-11-25 07:48:16 +0000
committer	Xin LI <delphij@FreeBSD.org>	2019-11-25 07:48:16 +0000
commit	6b2c1e49da284f28ec7b52f7c031474087e37104 (patch)
tree	1c6eabb549a0be6167f4f25f3e388afa0f730197 /contrib/expat
parent	6a14746c01a91a9f33f67d79565d01d96a879a3a (diff)
parent	987ba809b8add6260181a8c036ec3c017948ff56 (diff)
download	src-test2-6b2c1e49da284f28ec7b52f7c031474087e37104.tar.gz src-test2-6b2c1e49da284f28ec7b52f7c031474087e37104.zip