Index: vendor/expat/dist/Changes
===================================================================
--- vendor/expat/dist/Changes	(revision 355070)
+++ vendor/expat/dist/Changes	(revision 355071)
@@ -1,600 +1,756 @@
 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
        #204 #205  Fix 2.2.5 regression with suspend-resume while parsing
                     a document like '<root/>'
 
         Other changes:
        #165 #168  Autotools: Fix docbook-related configure syntax error
             #166  Autotools: Avoid grep option `-q` for Solaris
             #167  Autotools: Support
                     ./configure DOCBOOK_TO_MAN="xmlto man --skip-validation"
        #159 #167  Autotools: Support DOCBOOK_TO_MAN command which produces
                     xmlwf.1 rather than XMLWF.1; also covers case insensitive
                     file systems
             #181  Autotools: Drop -rpath option passed to libtool
             #188  Autotools: Detect and deny SGML docbook2man as ours is XML
             #188  Autotools/CMake: Support command db2x_docbook2man as well
             #174  CMake: Introduce option WARNINGS_AS_ERRORS, defaults to OFF
        #184 #185  CMake: Introduce option MSVC_USE_STATIC_CRT, defaults to OFF
        #207 #208  CMake: Introduce option XML_UNICODE and XML_UNICODE_WCHAR_T,
                     both defaulting to OFF
             #175  CMake: Prefer check_symbol_exists over check_function_exists
             #176  CMake: Create the same pkg-config file as with GNU Autotools
        #178 #179  CMake: Use GNUInstallDirs module to set proper defaults for
                     install directories
             #208  CMake: Utilize expat_config.h.cmake for XML_DEV_URANDOM
             #180  Windows: Fix compilation of test suite for Visual Studio 2008
   #131 #173 #202  Address compiler warnings
   #187 #190 #200  Fix miscellaneous typos
                   Version info bumped from 7:7:6 to 7:8:6
 
         Special thanks to:
             Anton Maklakov
             Benjamin Peterson
             Brad King
             Franek Korta
             Frank Rast
             Joe Orton
             luzpaz
             Pedro Vicente
             Rainer Jung
             Rhodri James
             Rolf Ade
             Rolf Eike Beer
             Thomas Beutlich
             Tomasz Kłoczko
 
 Release 2.2.5 Tue October 31 2017
         Bug fixes:
               #8  If the parser runs out of memory, make sure its internal
                     state reflects the memory it actually has, not the memory
                     it wanted to have.
              #11  The default handler wasn't being called when it should for
                     a SYSTEM or PUBLIC doctype if an entity declaration handler
                     was registered.
        #137 #138  Fix a case of mistakenly reported parsing success where
                     XML_StopParser was called from an element handler
             #162  Function XML_ErrorString was returning NULL rather than
                     a message for code XML_ERROR_INVALID_ARGUMENT
                     introduced with release 2.2.1
 
         Other changes:
             #106  xmlwf: Add argument -N adding notation declarations
         #75 #106  Test suite: Resolve expected failure cases where xmlwf
                     output was incomplete
             #127  Windows: Fix test suite compilation
        #126 #127  Windows: Fix compilation for Visual Studio 2012
                   Windows: Upgrade shipped project files to Visual Studio 2017
         #33 #132  tests: Mass-fix compilation for XML_UNICODE_WCHAR_T
             #129  examples: Fix compilation for XML_UNICODE_WCHAR_T
             #130  benchmark: Fix compilation for XML_UNICODE_WCHAR_T
             #144  xmlwf: Fix compilation for XML_UNICODE_WCHAR_T; still needs
                     Windows or MinGW for 2-byte wchar_t
               #9  Address two Clang Static Analyzer false positives
              #59  Resolve troublesome macros hiding parser struct membership
                     and dereferencing that pointer
               #6  Resolve superfluous internal malloc/realloc switch
        #153 #155  Improve docbook2x-man detection
             #160  Undefine NDEBUG in the test suite (rather than rejecting it)
             #161  Address compiler warnings
                   Version info bumped from 7:6:6 to 7:7:6
 
         Special thanks to:
             Benbuck Nason
             Hans Wennborg
             José Gutiérrez de la Concha
             Pedro Monreal Gonzalez
             Rhodri James
             Rolf Ade
             Stephen Groat
                  and
             Core Infrastructure Initiative
 
 Release 2.2.4 Sat August 19 2017
         Bug fixes:
             #115  Fix copying of partial characters for UTF-8 input
 
         Other changes:
             #109  Fix "make check" for non-x86 architectures that default
                     to unsigned type char (-128..127 rather than 0..255)
             #109  coverage.sh: Cover -funsigned-char
                   Autotools: Introduce --without-xmlwf argument
              #65  Autotools: Replace handwritten Makefile with GNU Automake
              #43  CMake: Auto-detect high quality entropy extractors, add new
                     option USE_libbsd=ON to use arc4random_buf of libbsd
              #74  CMake: Add -fno-strict-aliasing only where supported
             #114  CMake: Always honor manually set BUILD_* options
             #114  CMake: Compile man page if docbook2x-man is available, only
             #117  Include file tests/xmltest.log.expected in source tarball
                     (required for "make run-xmltest")
             #117  Include (existing) Visual Studio 2013 files in source tarball
                   Improve test suite error output
             #111  Fix some typos in documentation
                   Version info bumped from 7:5:6 to 7:6:6
 
         Special thanks to:
             Jakub Wilk
             Joe Orton
             Lin Tian
             Rolf Eike Beer
 
 Release 2.2.3 Wed August 2 2017
         Security fixes:
              #82  CVE-2017-11742 -- Windows: Fix DLL hijacking vulnerability
                     using Steve Holme's LoadLibrary wrapper for/of cURL
 
         Bug fixes:
              #85  Fix a dangling pointer issue related to realloc
 
         Other changes:
                   Increase code coverage
              #91  Linux: Allow getrandom to fail if nonblocking pool has not
                     yet been initialized and read /dev/urandom then, instead.
                     This is in line with what recent Python does.
              #81  Pre-10.7/Lion macOS: Support entropy from arc4random
              #86  Check that a UTF-16 encoding in an XML declaration has the
                     right endianness
         #4 #5 #7  Recover correctly when some reallocations fail
                   Repair "./configure && make" for systems without any
                     provider of high quality entropy
                     and try reading /dev/urandom on those
                   Ensure that user-defined character encodings have converter
                     functions when they are needed
                   Fix mis-leading description of argument -c in xmlwf.1
                   Rely on macro HAVE_ARC4RANDOM_BUF (rather than __CloudABI__)
                     for CloudABI
             #100  Fix use of SIPHASH_MAIN in siphash.h
              #23  Test suite: Fix memory leaks
                   Version info bumped from 7:4:6 to 7:5:6
 
         Special thanks to:
             Chanho Park
             Joe Orton
             Pascal Cuoq
             Rhodri James
             Simon McVittie
             Vadim Zeitlin
             Viktor Szakats
                  and
             Core Infrastructure Initiative
 
 Release 2.2.2 Wed July 12 2017
         Security fixes:
              #43  Protect against compilation without any source of high
                     quality entropy enabled, e.g. with CMake build system;
                     commit ff0207e6076e9828e536b8d9cd45c9c92069b895
              #60  Windows with _UNICODE:
                     Unintended use of LoadLibraryW with a non-wide string
                     resulted in failure to load advapi32.dll and degradation
                     in quality of used entropy when compiled with _UNICODE for
                     Windows; you can launch existing binaries with
                     EXPAT_ENTROPY_DEBUG=1 in the environment to inspect the
                     quality of entropy used during runtime; commits
                     * 95b95032f907ef1cd17ee7a9a1768010a825d61d
                     * 73a5a2e9c081f49f2d775cf7ced864158b68dc80
    [MOX-006]      Fix non-NULL parser parameter validation in XML_Parse;
                     resulted in NULL dereference, previously;
                     commit ac256dafdffc9622ab0dc2c62fcecb0dfcfa71fe
 
         Bug fixes:
              #69  Fix improper use of unsigned long long integer literals
 
         Other changes:
              #73  Start requiring a C99 compiler
              #49  Fix "==" Bashism in configure script
              #50  Fix too eager getrandom detection for Debian GNU/kFreeBSD
              #52    and macOS
              #51  Address lack of stdint.h in Visual Studio 2003 to 2008
              #58  Address compile warnings
              #68  Fix "./buildconf.sh && ./configure" for some versions
                     of Dash for /bin/sh
              #72  CMake: Ease use of Expat in context of a parent project
                     with multiple CMakeLists.txt files
              #72  CMake: Resolve mistaken executable permissions
              #76  Address compile warning with -DNDEBUG (not recommended!)
              #77  Address compile warning about macro redefinition
 
         Special thanks to:
             Alexander Bluhm
             Ben Boeckel
             Cătălin Răceanu
             Kerin Millar
             László Böszörményi
             S. P. Zeidler
             Segev Finer
             Václav Slavík
             Victor Stinner
             Viktor Szakats
                  and
             Radically Open Security
 
 Release 2.2.1 Sat June 17 2017
         Security fixes:
                   CVE-2017-9233 -- External entity infinite loop DoS
                     Details: https://libexpat.github.io/doc/cve-2017-9233/
                     Commit c4bf96bb51dd2a1b0e185374362ee136fe2c9d7f
    [MOX-002]      CVE-2016-9063 -- Detect integer overflow; commit
                     d4f735b88d9932bd5039df2335eefdd0723dbe20
                     (Fixed version of existing downstream patches!)
    (SF.net) #539  Fix regression from fix to CVE-2016-0718 cutting off
                     longer tag names; commits
                     * 896b6c1fd3b842f377d1b62135dccf0a579cf65d
                     * af507cef2c93cb8d40062a0abe43a4f4e9158fb2
              #16    * 0dbbf43fdb20f593ddf4fa1ff67288000dd4a7fd
              #25  More integer overflow detection (function poolGrow); commits
                     * 810b74e4703dcfdd8f404e3cb177d44684775143
                     * 44178553f3539ce69d34abee77a05e879a7982ac
    [MOX-002]      Detect overflow from len=INT_MAX call to XML_Parse; commits
                     * 4be2cb5afcc018d996f34bbbce6374b7befad47f
                     * 7e5b71b748491b6e459e5c9a1d090820f94544d8
    [MOX-005] #30  Use high quality entropy for hash initialization:
                     * arc4random_buf on BSD, systems with libbsd
                       (when configured with --with-libbsd), CloudABI
                     * RtlGenRandom on Windows XP / Server 2003 and later
                     * getrandom on Linux 3.17+
                     In a way, that's still part of CVE-2016-5300.
                     https://github.com/libexpat/libexpat/pull/30/commits
    [MOX-005]      For the low quality entropy extraction fallback code,
                     the parser instance address can no longer leak, commit
                     04ad658bd3079dd15cb60fc67087900f0ff4b083
    [MOX-003]      Prevent use of uninitialised variable; commit
    [MOX-004]        a4dc944f37b664a3ca7199c624a98ee37babdb4b
                   Add missing parameter validation to public API functions
                     and dedicated error code XML_ERROR_INVALID_ARGUMENT:
    [MOX-006]        * NULL checks; commits
                       * d37f74b2b7149a3a95a680c4c4cd2a451a51d60a (merge/many)
                       * 9ed727064b675b7180c98cb3d4f75efba6966681
                       * 6a747c837c50114dfa413994e07c0ba477be4534
                     * Negative length (XML_Parse); commit
    [MOX-002]          70db8d2538a10f4c022655d6895e4c3e78692e7f
    [MOX-001] #35  Change hash algorithm to William Ahern's version of SipHash
                     to go further with fixing CVE-2012-0876.
                     https://github.com/libexpat/libexpat/pull/39/commits
 
         Bug fixes:
              #32  Fix sharing of hash salt across parsers;
                     relevant where XML_ExternalEntityParserCreate is called
                     prior to XML_Parse, in particular (e.g. FBReader)
              #28  xmlwf: Auto-disable use of memory-mapping (and parsing
                     as a single chunk) for files larger than ~1 GB (2^30 bytes)
                     rather than failing with error "out of memory"
               #3  Fix double free after malloc failure in DTD code; commit
                     7ae9c3d3af433cd4defe95234eae7dc8ed15637f
              #17  Fix memory leak on parser error for unbound XML attribute
                     prefix with new namespaces defined in the same tag;
                     found by Google's OSS-Fuzz; commits
                     * 16f87daae5a16132e479e4f71862128c7a915c73
                     * b47dbc9745932c160893d433220e462bd605f8cd
                   xmlwf on Windows: Add missing calls to CloseHandle
 
         New features:
              #30  Introduced environment switch EXPAT_ENTROPY_DEBUG=1
                     for runtime debugging of entropy extraction
 
         Other changes:
                   Increase code coverage
              #33  Reject use of XML_UNICODE_WCHAR_T with sizeof(wchar_t) != 2;
                     XML_UNICODE_WCHAR_T was never meant to be used outside
                     of Windows; 4-byte wchar_t is common on Linux
    (SF.net) #538  Start using -fno-strict-aliasing
    (SF.net) #540  Support compilation against cloudlibc of CloudABI
                   Allow MinGW cross-compilation
    (SF.net) #534  CMake: Introduce option "BUILD_doc" (enabled by default)
                     to bypass compilation of the xmlwf.1 man page
    (SF.net)  pr2  CMake: Introduce option "INSTALL" (enabled by default)
                     to bypass installation of expat files
                   CMake: Fix ninja support
                   Autotools: Add parameters --enable-xml-context [COUNT]
                     and --disable-xml-context; default of context of 1024
                     bytes enabled unchanged
              #14  Drop AmigaOS 4.x code and includes
              #14  Drop ancient build systems:
                     * Borland C++ Builder
                     * OpenVMS
                     * Open Watcom
                     * Visual Studio 6.0
                     * Pre-X Mac OS (MPW Makefile)
                     If you happen to rely on some of these, please get in
                     touch for joining with maintenance.
              #10  Move from WIN32 to _WIN32
              #13  Fix "make run-xmltest" order instability
                   Address compile warnings
                   Bump version info from 7:2:6 to 7:3:6
                   Add AUTHORS file
 
         Infrastructure:
               #1  Migrate from SourceForge to GitHub (except downloads):
                     https://github.com/libexpat/
               #1  Re-create http://libexpat.org/ project website
                   Start utilizing Travis CI
 
         Special thanks to:
             Andy Wang
             Don Lewis
             Ed Schouten
             Karl Waclawek
             Pascal Cuoq
             Rhodri James
             Sergei Nikulov
             Tobias Taschner
             Viktor Szakats
                  and
             Core Infrastructure Initiative
             Mozilla Foundation (MOSS Track 3: Secure Open Source)
             Radically Open Security
 
 Release 2.2.0 Tue June 21 2016
         Security fixes:
             #537  CVE-2016-0718 -- Fix crash on malformed input
                   CVE-2016-4472 -- Improve insufficient fix to CVE-2015-1283 /
                                    CVE-2015-2716 introduced with Expat 2.1.1
             #499  CVE-2016-5300 -- Use more entropy for hash initialization
                                    than the original fix to CVE-2012-0876
             #519  CVE-2012-6702 -- Resolve troublesome internal call to srand
                                    that was introduced with Expat 2.1.0
                                    when addressing CVE-2012-0876 (issue #496)
 
         Bug fixes:
                   Fix uninitialized reads of size 1
                     (e.g. in little2_updatePosition)
                   Fix detection of UTF-8 character boundaries
 
         Other changes:
             #532  Fix compilation for Visual Studio 2010 (keyword "C99")
                   Autotools: Resolve use of "$<" to better support bmake
                   Autotools: Add QA script "qa.sh" (and make target "qa")
                   Autotools: Respect CXXFLAGS if given
                   Autotools: Fix "make run-xmltest"
                   Autotools: Have "make run-xmltest" check for expected output
              p90  CMake: Fix static build (BUILD_shared=OFF) on Windows
             #536  CMake: Add soversion, support -DNO_SONAME=yes to bypass
             #323  CMake: Add suffix "d" to differentiate debug from release
                   CMake: Define WIN32 with CMake on Windows
                   Annotate memory allocators for GCC
                   Address all currently known compile warnings
                   Make sure that API symbols remain visible despite
                     -fvisibility=hidden
                   Remove executable flag from source files
                   Resolve COMPILED_FROM_DSP in favor of WIN32
 
         Special thanks to:
             Björn Lindahl
             Christian Heimes
             Cristian Rodríguez
             Daniel Krügler
             Gustavo Grieco
             Karl Waclawek
             László Böszörményi
             Marco Grassi
             Pascal Cuoq
             Sergei Nikulov
             Thomas Beutlich
             Warren Young
             Yann Droneaud
 
 Release 2.1.1 Sat March 12 2016
         Security fixes:
             #582: CVE-2015-1283 - Multiple integer overflows in XML_GetBuffer
 
         Bug fixes:
             #502: Fix potential null pointer dereference
             #520: Symbol XML_SetHashSalt was not exported
             Output of "xmlwf -h" was incomplete
 
         Other changes:
             #503: Document behavior of calling XML_SetHashSalt with salt 0
             Minor improvements to man page xmlwf(1)
             Improvements to the experimental CMake build system
             libtool now invoked with --verbose
 
 Release 2.1.0 Sat March 24 2012
         - Security fixes:
           #2958794: CVE-2012-1148 - Memory leak in poolGrow.
           #2895533: CVE-2012-1147 - Resource leak in readfilemap.c.
           #3496608: CVE-2012-0876 - Hash DOS attack.
           #2894085: CVE-2009-3560 - Buffer over-read and crash in big2_toUtf8().
           #1990430: CVE-2009-3720 - Parser crash with special UTF-8 sequences.
         - Bug Fixes:
           #1742315: Harmful XML_ParserCreateNS suggestion.
           #1785430: Expat build fails on linux-amd64 with gcc version>=4.1 -O3.
           #1983953, 2517952, 2517962, 2649838: 
                 Build modifications using autoreconf instead of buildconf.sh.
           #2815947, #2884086: OBJEXT and EXEEXT support while building.
           #2517938: xmlwf should return non-zero exit status if not well-formed.
           #2517946: Wrong statement about XMLDecl in xmlwf.1 and xmlwf.sgml.
           #2855609: Dangling positionPtr after error.
           #2990652: CMake support.
           #3010819: UNEXPECTED_STATE with a trailing "%" in entity value.
           #3206497: Uninitialized memory returned from XML_Parse.
           #3287849: make check fails on mingw-w64.
         - Patches:
           #1749198: pkg-config support.
           #3010222: Fix for bug #3010819.
           #3312568: CMake support.
           #3446384: Report byte offsets for attr names and values.
         - New Features / API changes:
           Added new API member XML_SetHashSalt() that allows setting an initial
                 value (salt) for hash calculations. This is part of the fix for
                 bug #3496608 to randomize hash parameters.
           When compiled with XML_ATTR_INFO defined, adds new API member
                 XML_GetAttributeInfo() that allows retrieving the byte
                 offsets for attribute names and values (patch #3446384).
           Added CMake build system.
                 See bug #2990652 and patch #3312568.
           Added run-benchmark target to Makefile.in - relies on testdata module
                 present in the same relative location as in the repository.
           
 Release 2.0.1 Tue June 5 2007
         - Fixed bugs #1515266, #1515600: The character data handler's calling
           of XML_StopParser() was not handled properly; if the parser was
           stopped and the handler set to NULL, the parser would segfault.
         - Fixed bug #1690883: Expat failed on EBCDIC systems as it assumed
           some character constants to be ASCII encoded.
         - Minor cleanups of the test harness.
         - Fixed xmlwf bug #1513566: "out of memory" error on file size zero.
         - Fixed outline.c bug #1543233: missing a final XML_ParserFree() call.
         - Fixes and improvements for Windows platform:
           bugs #1409451, #1476160, #1548182, #1602769, #1717322.
         - Build fixes for various platforms:
           HP-UX, Tru64, Solaris 9: patch #1437840, bug #1196180.
           All Unix: #1554618 (refreshed config.sub/config.guess).
                     #1490371, #1613457: support both, DESTDIR and INSTALL_ROOT,
                     without relying on GNU-Make specific features.
           #1647805: Patched configure.in to work better with Intel compiler.
         - Fixes to Makefile.in to have make check work correctly:
           bugs #1408143, #1535603, #1536684.
         - Added Open Watcom support: patch #1523242.
 
 Release 2.0.0 Wed Jan 11 2006
         - We no longer use the "check" library for C unit testing; we
           always use the (partial) internal implementation of the API.
         - Report XML_NS setting via XML_GetFeatureList().
         - Fixed headers for use from C++.
         - XML_GetCurrentLineNumber() and  XML_GetCurrentColumnNumber()
           now return unsigned integers.
         - Added XML_LARGE_SIZE switch to enable 64-bit integers for
           byte indexes and line/column numbers.
         - Updated to use libtool 1.5.22 (the most recent).
         - Added support for AmigaOS.
         - Some mostly minor bug fixes. SF issues include: #1006708,
           #1021776, #1023646, #1114960, #1156398, #1221160, #1271642.
 
 Release 1.95.8 Fri Jul 23 2004
         - Major new feature: suspend/resume.  Handlers can now request
           that a parse be suspended for later resumption or aborted
           altogether.  See "Temporarily Stopping Parsing" in the
           documentation for more details.
         - Some mostly minor bug fixes, but compilation should no
           longer generate warnings on most platforms.  SF issues
           include: #827319, #840173, #846309, #888329, #896188, #923913,
           #928113, #961698, #985192.
 
 Release 1.95.7 Mon Oct 20 2003
         - Fixed enum XML_Status issue (reported on SourceForge many
           times), so compilers that are properly picky will be happy.
         - Introduced an XMLCALL macro to control the calling
           convention used by the Expat API; this macro should be used
           to annotate prototypes and definitions of callback
           implementations in code compiled with a calling convention
           other than the default convention for the host platform.
         - Improved ability to build without the configure-generated
           expat_config.h header.  This is useful for applications
           which embed Expat rather than linking in the library.
         - Fixed a variety of bugs: see SF issues #458907, #609603,
           #676844, #679754, #692878, #692964, #695401, #699323, #699487,
           #820946.
         - Improved hash table lookups.
         - Added more regression tests and improved documentation.
 
 Release 1.95.6 Tue Jan 28 2003
         - Added XML_FreeContentModel().
         - Added XML_MemMalloc(), XML_MemRealloc(), XML_MemFree().
         - Fixed a variety of bugs: see SF issues #615606, #616863,
           #618199, #653180, #673791.
         - Enhanced the regression test suite.
         - Man page improvements: includes SF issue #632146.
 
 Release 1.95.5 Fri Sep 6 2002
         - Added XML_UseForeignDTD() for improved SAX2 support.
         - Added XML_GetFeatureList().
         - Defined XML_Bool type and the values XML_TRUE and XML_FALSE.
         - Use an incomplete struct instead of a void* for the parser
           (may not retain).
         - Fixed UTF-8 decoding bug that caused legal UTF-8 to be rejected.
         - Finally fixed bug where default handler would report DTD
           events that were already handled by another handler.
           Initial patch contributed by Darryl Miles.
         - Removed unnecessary DllMain() function that caused static
           linking into a DLL to be difficult.
         - Added VC++ projects for building static libraries.
         - Reduced line-length for all source code and headers to be
           no longer than 80 characters, to help with AS/400 support.
         - Reduced memory copying during parsing (SF patch #600964).
         - Fixed a variety of bugs: see SF issues #580793, #434664,
           #483514, #580503, #581069, #584041, #584183, #584832, #585537,
           #596555, #596678, #598352, #598944, #599715, #600479, #600971.
 
 Release 1.95.4 Fri Jul 12 2002
         - Added support for VMS, contributed by Craig Berry.  See
           vms/README.vms for more information.
         - Added Mac OS (classic) support, with a makefile for MPW,
           contributed by Thomas Wegner and Daryle Walker.
         - Added Borland C++ Builder 5 / BCC 5.5 support, contributed
           by Patrick McConnell (SF patch #538032).
         - Fixed a variety of bugs: see SF issues #441449, #563184,
           #564342, #566334, #566901, #569461, #570263, #575168, #579196.
         - Made skippedEntityHandler conform to SAX2 (see source comment)
         - Re-implemented WFC: Entity Declared from XML 1.0 spec and
           added a new error "entity declared in parameter entity":
           see SF bug report #569461 and SF patch #578161
         - Re-implemented section 5.1 from XML 1.0 spec:
           see SF bug report #570263 and SF patch #578161
 
 Release 1.95.3 Mon Jun 3 2002
         - Added a project to the MSVC workspace to create a wchar_t
           version of the library; the DLLs are named libexpatw.dll.
         - Changed the name of the Windows DLLs from expat.dll to
           libexpat.dll; this fixes SF bug #432456.
         - Added the XML_ParserReset() API function.
         - Fixed XML_SetReturnNSTriplet() to work for element names.
         - Made the XML_UNICODE builds usable (thanks, Karl!).
         - Allow xmlwf to read from standard input.
         - Install a man page for xmlwf on Unix systems.
         - Fixed many bugs; see SF bug reports #231864, #461380, #464837,
           #466885, #469226, #477667, #484419, #487840, #494749, #496505,
           #547350.  Other bugs which we can't test as easily may also
           have been fixed, especially in the area of build support.
 
 Release 1.95.2 Fri Jul 27 2001
         - More changes to make MSVC happy with the build; add a single
           workspace to support both the library and xmlwf application.
         - Added a Windows installer for Windows users; includes
           xmlwf.exe.
         - Added compile-time constants that can be used to determine the
           Expat version
         - Removed a lot of GNU-specific dependencies to aide portability
           among the various Unix flavors.
         - Fix the UTF-8 BOM bug.
         - Cleaned up warning messages for several compilers.
         - Added the -Wall, -Wstrict-prototypes options for GCC.
 
 Release 1.95.1 Sun Oct 22 15:11:36 EDT 2000
         - Changes to get expat to build under Microsoft compiler
         - Removed all aborts and instead return an UNEXPECTED_STATE error.
         - Fixed a bug where a stray '%' in an entity value would cause an
           abort.
         - Defined XML_SetEndNamespaceDeclHandler. Thanks to Darryl Miles for
           finding this oversight.
         - Changed default patterns in lib/Makefile.in to fit non-GNU makes
           Thanks to robin@unrated.net for reporting and providing an
           account to test on.
         - The reference had the wrong label for XML_SetStartNamespaceDecl.
           Reported by an anonymous user.
 
 Release 1.95.0 Fri Sep 29 2000
         - XML_ParserCreate_MM
                 Allows you to set a memory management suite to replace the
                 standard malloc,realloc, and free.
         - XML_SetReturnNSTriplet
                 If you turn this feature on when namespace processing is in
                 effect, then qualified, prefixed element and attribute names
                 are returned as "uri|name|prefix" where '|' is whatever
                 separator character is used in namespace processing.
         - Merged in features from perl-expat
                 o XML_SetElementDeclHandler
                 o XML_SetAttlistDeclHandler
                 o XML_SetXmlDeclHandler
                 o XML_SetEntityDeclHandler
                 o StartDoctypeDeclHandler takes 3 additional parameters:
                         sysid, pubid, has_internal_subset
                 o Many paired handler setters (like XML_SetElementHandler)
                   now have corresponding individual handler setters
                 o XML_GetInputContext for getting the input context of
                   the current parse position.
         - Added reference material
         - Packaged into a distribution that builds a sharable library
Index: vendor/expat/dist/FREEBSD-Xlist
===================================================================
--- vendor/expat/dist/FREEBSD-Xlist	(revision 355070)
+++ vendor/expat/dist/FREEBSD-Xlist	(revision 355071)
@@ -1,21 +1,22 @@
 # $FreeBSD$
 *.MPW
 *.cmake
 *.def
 *.dsp
 *.dsw
 *.m4
 *.pc.in
 *.vcxproj*
 *config.h
+cmake
 CMake*
 Configure*
 amiga
 bcb5
 configure
 conftools
 doc/valid-xhtml10.png
 expat.sln
 m4
 vms
 win32
Index: vendor/expat/dist/Makefile.am
===================================================================
--- vendor/expat/dist/Makefile.am	(revision 355070)
+++ vendor/expat/dist/Makefile.am	(revision 355071)
@@ -1,153 +1,154 @@
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 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
 
 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) \
     $(_EXTRA_DIST_WINDOWS) \
     \
     conftools/expat.m4 \
     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
 
 
 .PHONY: buildlib
 buildlib:
 	@echo 'ERROR: Running "make buildlib LIBRARY=libexpatw.la"' >&2
 	@echo 'ERROR: is no longer supported.  INSTEAD please:' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Mass-patch Makefile.am, e.g.' >&2
 	@echo 'ERROR:    # find -name Makefile.am -exec sed \' >&2
 	@echo 'ERROR:          -e "s,libexpat\.la,libexpatw.la," \' >&2
 	@echo 'ERROR:          -e "s,libexpat_la,libexpatw_la," \' >&2
 	@echo 'ERROR:          -i {} +' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Run automake to re-generate Makefile.in files' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Use "./configure --without-xmlwf" and/or' >&2
 	@echo 'ERROR:    "make -C lib all install" to bypass compilation' >&2
 	@echo 'ERROR:    of xmlwf (e.g. with -DXML_UNICODE)' >&2
 	@echo 'ERROR:' >&2
 	@false
 
 
 .PHONY: run-benchmark
 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; \
 	else \
 		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
 	@false
 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
Index: vendor/expat/dist/Makefile.in
===================================================================
--- vendor/expat/dist/Makefile.in	(revision 355070)
+++ vendor/expat/dist/Makefile.in	(revision 355071)
@@ -1,1027 +1,1034 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
 	$(am__configure_deps) $(am__DIST_COMMON)
 am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
  configure.lineno config.status.lineno
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = expat_config.h
 CONFIG_CLEAN_FILES = expat.pc run.sh
 CONFIG_CLEAN_VPATH_FILES =
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 am__v_at_0 = @
 am__v_at_1 = 
 SOURCES =
 DIST_SOURCES =
 RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
 	ctags-recursive dvi-recursive html-recursive info-recursive \
 	install-data-recursive install-dvi-recursive \
 	install-exec-recursive install-html-recursive \
 	install-info-recursive install-pdf-recursive \
 	install-ps-recursive install-recursive installcheck-recursive \
 	installdirs-recursive pdf-recursive ps-recursive \
 	tags-recursive uninstall-recursive
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     *) f=$$p;; \
   esac;
 am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
 am__install_max = 40
 am__nobase_strip_setup = \
   srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
 am__nobase_strip = \
   for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
 am__nobase_list = $(am__nobase_strip_setup); \
   for p in $$list; do echo "$$p $$p"; done | \
   sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
   $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
     if (++n[$$2] == $(am__install_max)) \
       { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
     END { for (dir in files) print dir, files[dir] }'
 am__base_list = \
   sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
   sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
 am__uninstall_files_from_dir = { \
   test -z "$$files" \
     || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
     || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
 am__installdirs = "$(DESTDIR)$(pkgconfigdir)"
 DATA = $(pkgconfig_DATA)
 RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
   distclean-recursive maintainer-clean-recursive
 am__recursive_targets = \
   $(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,
 # and print each of them once, without duplicates.  Input order is
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 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)
 am__remove_distdir = \
   if test -d "$(distdir)"; then \
     find "$(distdir)" -type d ! -perm -200 -exec chmod u+w {} ';' \
       && rm -rf "$(distdir)" \
       || { sleep 5 && rm -rf "$(distdir)"; }; \
   else :; fi
 am__post_remove_distdir = $(am__remove_distdir)
 am__relativize = \
   dir0=`pwd`; \
   sed_first='s,^\([^/]*\)/.*$$,\1,'; \
   sed_rest='s,^[^/]*/*,,'; \
   sed_last='s,^.*/\([^/]*\)$$,\1,'; \
   sed_butlast='s,/*[^/]*$$,,'; \
   while test -n "$$dir1"; do \
     first=`echo "$$dir1" | sed -e "$$sed_first"`; \
     if test "$$first" != "."; then \
       if test "$$first" = ".."; then \
         dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
         dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
       else \
         first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
         if test "$$first2" = "$$first"; then \
           dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
         else \
           dir2="../$$dir2"; \
         fi; \
         dir0="$$dir0"/"$$first"; \
       fi; \
     fi; \
     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$$'
 distcleancheck_listfiles = find . -type f -print
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 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) \
     $(_EXTRA_DIST_WINDOWS) \
     \
     conftools/expat.m4 \
     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
 	$(MAKE) $(AM_MAKEFLAGS) all-recursive
 
 .SUFFIXES:
 am--refresh: Makefile
 	@:
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      echo ' cd $(srcdir) && $(AUTOMAKE) --foreign'; \
 	      $(am__cd) $(srcdir) && $(AUTOMAKE) --foreign \
 		&& exit 0; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --foreign Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	$(SHELL) ./config.status --recheck
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	$(am__cd) $(srcdir) && $(AUTOCONF)
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	$(am__cd) $(srcdir) && $(ACLOCAL) $(ACLOCAL_AMFLAGS)
 $(am__aclocal_m4_deps):
 
 expat_config.h: stamp-h1
 	@test -f $@ || rm -f stamp-h1
 	@test -f $@ || $(MAKE) $(AM_MAKEFLAGS) stamp-h1
 
 stamp-h1: $(srcdir)/expat_config.h.in $(top_builddir)/config.status
 	@rm -f stamp-h1
 	cd $(top_builddir) && $(SHELL) ./config.status expat_config.h
 $(srcdir)/expat_config.h.in:  $(am__configure_deps) 
 	($(am__cd) $(top_srcdir) && $(AUTOHEADER))
 	rm -f stamp-h1
 	touch $@
 
 distclean-hdr:
 	-rm -f expat_config.h stamp-h1
 expat.pc: $(top_builddir)/config.status $(srcdir)/expat.pc.in
 	cd $(top_builddir) && $(SHELL) ./config.status $@
 run.sh: $(top_builddir)/config.status $(srcdir)/run.sh.in
 	cd $(top_builddir) && $(SHELL) ./config.status $@
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 
 distclean-libtool:
 	-rm -f libtool config.lt
 install-pkgconfigDATA: $(pkgconfig_DATA)
 	@$(NORMAL_INSTALL)
 	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
 	if test -n "$$list"; then \
 	  echo " $(MKDIR_P) '$(DESTDIR)$(pkgconfigdir)'"; \
 	  $(MKDIR_P) "$(DESTDIR)$(pkgconfigdir)" || exit 1; \
 	fi; \
 	for p in $$list; do \
 	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
 	  echo "$$d$$p"; \
 	done | $(am__base_list) | \
 	while read files; do \
 	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(pkgconfigdir)'"; \
 	  $(INSTALL_DATA) $$files "$(DESTDIR)$(pkgconfigdir)" || exit $$?; \
 	done
 
 uninstall-pkgconfigDATA:
 	@$(NORMAL_UNINSTALL)
 	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
 	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
 	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
 
 # This directory's subdirectories are mostly independent; you can cd
 # into them and run 'make' without going through this Makefile.
 # To change the values of 'make' variables: instead of editing Makefiles,
 # (1) if the variable is set in 'config.status', edit 'config.status'
 #     (which will cause the Makefiles to be regenerated when you run 'make');
 # (2) otherwise, pass the desired values on the 'make' command line.
 $(am__recursive_targets):
 	@fail=; \
 	if $(am__make_keepgoing); then \
 	  failcom='fail=yes'; \
 	else \
 	  failcom='exit 1'; \
 	fi; \
 	dot_seen=no; \
 	target=`echo $@ | sed s/-recursive//`; \
 	case "$@" in \
 	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
 	  *) list='$(SUBDIRS)' ;; \
 	esac; \
 	for subdir in $$list; do \
 	  echo "Making $$target in $$subdir"; \
 	  if test "$$subdir" = "."; then \
 	    dot_seen=yes; \
 	    local_target="$$target-am"; \
 	  else \
 	    local_target="$$target"; \
 	  fi; \
 	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
 	  || eval $$failcom; \
 	done; \
 	if test "$$dot_seen" = "no"; then \
 	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
 	fi; test -z "$$fail"
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-recursive
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
 	  include_option=--etags-include; \
 	  empty_fix=.; \
 	else \
 	  include_option=--include; \
 	  empty_fix=; \
 	fi; \
 	list='$(SUBDIRS)'; for subdir in $$list; do \
 	  if test "$$subdir" = .; then :; else \
 	    test ! -f $$subdir/TAGS || \
 	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
 	  fi; \
 	done; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-recursive
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscope: cscope.files
 	test ! -s cscope.files \
 	  || $(CSCOPE) -b -q $(AM_CSCOPEFLAGS) $(CSCOPEFLAGS) -i cscope.files $(CSCOPE_ARGS)
 clean-cscope:
 	-rm -f cscope.files
 cscope.files: clean-cscope cscopelist
 cscopelist: cscopelist-recursive
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.files
 
 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'`; \
 	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
 	list='$(DISTFILES)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
 	  if test "$$subdir" = .; then :; else \
 	    $(am__make_dryrun) \
 	      || test -d "$(distdir)/$$subdir" \
 	      || $(MKDIR_P) "$(distdir)/$$subdir" \
 	      || exit 1; \
 	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
 	    $(am__relativize); \
 	    new_distdir=$$reldir; \
 	    dir1=$$subdir; dir2="$(top_distdir)"; \
 	    $(am__relativize); \
 	    new_top_distdir=$$reldir; \
 	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
 	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
 	    ($(am__cd) $$subdir && \
 	      $(MAKE) $(AM_MAKEFLAGS) \
 	        top_distdir="$$new_top_distdir" \
 	        distdir="$$new_distdir" \
 		am__remove_distdir=: \
 		am__skip_length_check=: \
 		am__skip_mode_fix=: \
 	        distdir) \
 	      || exit 1; \
 	  fi; \
 	done
 	-test -n "$(am__skip_mode_fix)" \
 	|| find "$(distdir)" -type d ! -perm -755 \
 		-exec chmod u+rwx,go+rx {} \; -o \
 	  ! -type d ! -perm -444 -links 1 -exec chmod a+r {} \; -o \
 	  ! -type d ! -perm -400 -exec chmod a+r {} \; -o \
 	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
 	|| chmod -R a+r "$(distdir)"
 dist-gzip: distdir
 	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
 	$(am__post_remove_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)
 
 dist-tarZ: distdir
 	@echo WARNING: "Support for distribution archives compressed with" \
 		       "legacy program 'compress' is deprecated." >&2
 	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
 	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
 	$(am__post_remove_distdir)
 
 dist-shar: distdir
 	@echo WARNING: "Support for shar distribution archives is" \
 	               "deprecated." >&2
 	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
 	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
 	$(am__post_remove_distdir)
 
 dist-zip: distdir
 	-rm -f $(distdir).zip
 	zip -rq $(distdir).zip $(distdir)
 	$(am__post_remove_distdir)
 
 dist dist-all:
 	$(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS) am__post_remove_distdir='@:'
 	$(am__post_remove_distdir)
 
 # This target untars the dist file and tries a VPATH configuration.  Then
 # it guarantees that the distribution is self-contained by making another
 # tarfile.
 distcheck: dist
 	case '$(DIST_ARCHIVES)' in \
 	*.tar.gz*) \
 	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
 	*.tar.bz2*) \
 	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
 	*.tar.lz*) \
 	  lzip -dc $(distdir).tar.lz | $(am__untar) ;;\
 	*.tar.xz*) \
 	  xz -dc $(distdir).tar.xz | $(am__untar) ;;\
 	*.tar.Z*) \
 	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
 	*.shar.gz*) \
 	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
 	*.zip*) \
 	  unzip $(distdir).zip ;;\
 	esac
 	chmod -R a-w $(distdir)
 	chmod u+w $(distdir)
 	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
 	chmod a-w $(distdir)
 	test -d $(distdir)/_build || exit 0; \
 	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \
 	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
 	  && am__cwd=`pwd` \
 	  && $(am__cd) $(distdir)/_build/sub \
 	  && ../../configure \
 	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
 	    $(DISTCHECK_CONFIGURE_FLAGS) \
 	    --srcdir=../.. --prefix="$$dc_install_base" \
 	  && $(MAKE) $(AM_MAKEFLAGS) \
 	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
 	  && $(MAKE) $(AM_MAKEFLAGS) check \
 	  && $(MAKE) $(AM_MAKEFLAGS) install \
 	  && $(MAKE) $(AM_MAKEFLAGS) installcheck \
 	  && $(MAKE) $(AM_MAKEFLAGS) uninstall \
 	  && $(MAKE) $(AM_MAKEFLAGS) distuninstallcheck_dir="$$dc_install_base" \
 	        distuninstallcheck \
 	  && chmod -R a-w "$$dc_install_base" \
 	  && ({ \
 	       (cd ../.. && umask 077 && mkdir "$$dc_destdir") \
 	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" install \
 	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" uninstall \
 	       && $(MAKE) $(AM_MAKEFLAGS) DESTDIR="$$dc_destdir" \
 	            distuninstallcheck_dir="$$dc_destdir" distuninstallcheck; \
 	      } || { rm -rf "$$dc_destdir"; exit 1; }) \
 	  && rm -rf "$$dc_destdir" \
 	  && $(MAKE) $(AM_MAKEFLAGS) dist \
 	  && rm -rf $(DIST_ARCHIVES) \
 	  && $(MAKE) $(AM_MAKEFLAGS) distcleancheck \
 	  && cd "$$am__cwd" \
 	  || exit 1
 	$(am__post_remove_distdir)
 	@(echo "$(distdir) archives ready for distribution: "; \
 	  list='$(DIST_ARCHIVES)'; for i in $$list; do echo $$i; done) | \
 	  sed -e 1h -e 1s/./=/g -e 1p -e 1x -e '$$p' -e '$$x'
 distuninstallcheck:
 	@test -n '$(distuninstallcheck_dir)' || { \
 	  echo 'ERROR: trying to run $@ with an empty' \
 	       '$$(distuninstallcheck_dir)' >&2; \
 	  exit 1; \
 	}; \
 	$(am__cd) '$(distuninstallcheck_dir)' || { \
 	  echo 'ERROR: cannot chdir into $(distuninstallcheck_dir)' >&2; \
 	  exit 1; \
 	}; \
 	test `$(am__distuninstallcheck_listfiles) | wc -l` -eq 0 \
 	   || { echo "ERROR: files left after uninstall:" ; \
 	        if test -n "$(DESTDIR)"; then \
 	          echo "  (check DESTDIR support)"; \
 	        fi ; \
 	        $(distuninstallcheck_listfiles) ; \
 	        exit 1; } >&2
 distcleancheck: distclean
 	@if test '$(srcdir)' = . ; then \
 	  echo "ERROR: distcleancheck can only run from a VPATH build" ; \
 	  exit 1 ; \
 	fi
 	@test `$(distcleancheck_listfiles) | wc -l` -eq 0 \
 	  || { echo "ERROR: files left in build directory after distclean:" ; \
 	       $(distcleancheck_listfiles) ; \
 	       exit 1; } >&2
 check-am: all-am
 check: check-recursive
 all-am: Makefile $(DATA) expat_config.h
 installdirs: installdirs-recursive
 installdirs-am:
 	for dir in "$(DESTDIR)$(pkgconfigdir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
 install: install-recursive
 install-exec: install-exec-recursive
 install-data: install-data-recursive
 uninstall: uninstall-recursive
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-recursive
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-recursive
 
 clean-am: clean-generic clean-libtool mostlyclean-am
 
 distclean: distclean-recursive
 	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
 	-rm -f Makefile
 distclean-am: clean-am distclean-generic distclean-hdr \
 	distclean-libtool distclean-tags
 
 dvi: dvi-recursive
 
 dvi-am:
 
 html: html-recursive
 
 html-am:
 
 info: info-recursive
 
 info-am:
 
 install-data-am: install-pkgconfigDATA
 
 install-dvi: install-dvi-recursive
 
 install-dvi-am:
 
 install-exec-am:
 
 install-html: install-html-recursive
 
 install-html-am:
 
 install-info: install-info-recursive
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-recursive
 
 install-pdf-am:
 
 install-ps: install-ps-recursive
 
 install-ps-am:
 
 installcheck-am:
 
 maintainer-clean: maintainer-clean-recursive
 	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
 	-rm -rf $(top_srcdir)/autom4te.cache
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
 mostlyclean: mostlyclean-recursive
 
 mostlyclean-am: mostlyclean-generic mostlyclean-libtool
 
 pdf: pdf-recursive
 
 pdf-am:
 
 ps: ps-recursive
 
 ps-am:
 
 uninstall-am: uninstall-pkgconfigDATA
 
 .MAKE: $(am__recursive_targets) all install-am install-strip
 
 .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
 	am--refresh check check-am clean clean-cscope clean-generic \
 	clean-libtool cscope cscopelist-am ctags ctags-am dist \
 	dist-all dist-bzip2 dist-gzip dist-lzip dist-shar dist-tarZ \
 	dist-xz dist-zip distcheck distclean distclean-generic \
 	distclean-hdr distclean-libtool distclean-tags distcleancheck \
 	distdir distuninstallcheck 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-pkgconfigDATA \
 	install-ps install-ps-am install-strip installcheck \
 	installcheck-am installdirs installdirs-am maintainer-clean \
 	maintainer-clean-generic mostlyclean mostlyclean-generic \
 	mostlyclean-libtool pdf pdf-am ps ps-am tags tags-am uninstall \
 	uninstall-am uninstall-pkgconfigDATA
 
 .PRECIOUS: Makefile
 
 
 .PHONY: buildlib
 buildlib:
 	@echo 'ERROR: Running "make buildlib LIBRARY=libexpatw.la"' >&2
 	@echo 'ERROR: is no longer supported.  INSTEAD please:' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Mass-patch Makefile.am, e.g.' >&2
 	@echo 'ERROR:    # find -name Makefile.am -exec sed \' >&2
 	@echo 'ERROR:          -e "s,libexpat\.la,libexpatw.la," \' >&2
 	@echo 'ERROR:          -e "s,libexpat_la,libexpatw_la," \' >&2
 	@echo 'ERROR:          -i {} +' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Run automake to re-generate Makefile.in files' >&2
 	@echo 'ERROR:' >&2
 	@echo 'ERROR:  * Use "./configure --without-xmlwf" and/or' >&2
 	@echo 'ERROR:    "make -C lib all install" to bypass compilation' >&2
 	@echo 'ERROR:    of xmlwf (e.g. with -DXML_UNICODE)' >&2
 	@echo 'ERROR:' >&2
 	@false
 
 .PHONY: run-benchmark
 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; \
 	else \
 		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.
 .NOEXPORT:
Index: vendor/expat/dist/README.md
===================================================================
--- vendor/expat/dist/README.md	(revision 355070)
+++ vendor/expat/dist/README.md	(revision 355071)
@@ -1,126 +1,188 @@
 [![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.
 Expat is a stream-oriented XML parser.  This means that you register
 handlers with the parser before starting the parse.  These handlers
 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
 developers.
 
 Expat is [free software](https://www.gnu.org/philosophy/free-sw.en.html).
 You may copy, distribute, and modify it under the terms of the License
 contained in the file
 [`COPYING`](https://github.com/libexpat/libexpat/blob/master/expat/COPYING)
 distributed with this package.
 This license is the same as the MIT/X Consortium license.
 
 If you are building Expat from a check-out from the
 [Git repository](https://github.com/libexpat/libexpat/),
 you need to run a script that generates the configure script using the
 GNU autoconf and libtool tools.  To do this, you need to have
 autoconf 2.58 or newer. Run the script like this:
 
 ```console
 ./buildconf.sh
 ```
 
 Once this has been done, follow the same instructions as for building
 from a source distribution.
 
 To build Expat from a source distribution, you first run the
 configuration shell script in the top level distribution directory:
 
 ```console
 ./configure
 ```
 
 There are many options which you may provide to configure (which you
 can discover by running configure with the `--help` option).  But the
 one of most interest is the one that sets the installation directory.
 By default, the configure script will set things up to install
 libexpat into `/usr/local/lib`, `expat.h` into `/usr/local/include`, and
 `xmlwf` into `/usr/local/bin`.  If, for example, you'd prefer to install
 into `/home/me/mystuff/lib`, `/home/me/mystuff/include`, and
 `/home/me/mystuff/bin`, you can tell `configure` about that with:
 
 ```console
 ./configure --prefix=/home/me/mystuff
 ```
 
 Another interesting option is to enable 64-bit integer support for
 line and column numbers and the over-all byte index:
 
 ```console
 ./configure CPPFLAGS=-DXML_LARGE_SIZE
 ```
 
 However, such a modification would be a breaking change to the ABI
 and is therefore not recommended for general use &mdash; e.g. as part of
 a Linux distribution &mdash; but rather for builds with special requirements.
 
 After running the configure script, the `make` command will build
 things and `make install` will install things into their proper
 location.  Have a look at the `Makefile` to learn about additional
 `make` options.  Note that you need to have write permission into
 the directories into which things will be installed.
 
 If you are interested in building Expat to provide document
 information in UTF-16 encoding rather than the default UTF-8, follow
 these instructions (after having run `make distclean`).
 Please note that we configure with `--without-xmlwf` as xmlwf does not
 support this mode of compilation (yet):
 
 1. Mass-patch `Makefile.am` files to use `libexpatw.la` for a library name:
    <br/>
    `find -name Makefile.am -exec sed
        -e 's,libexpat\.la,libexpatw.la,'
        -e 's,libexpat_la,libexpatw_la,'
        -i {} +`
 
 1. Run `automake` to re-write `Makefile.in` files:<br/>
    `automake`
 
 1. For UTF-16 output as unsigned short (and version/error strings as char),
    run:<br/>
    `./configure CPPFLAGS=-DXML_UNICODE --without-xmlwf`<br/>
    For UTF-16 output as `wchar_t` (incl. version/error strings), run:<br/>
    `./configure CFLAGS="-g -O2 -fshort-wchar" CPPFLAGS=-DXML_UNICODE_WCHAR_T
        --without-xmlwf`
    <br/>Note: The latter requires libc compiled with `-fshort-wchar`, as well.
 
 1. Run `make` (which excludes xmlwf).
 
 1. Run `make install` (again, excludes xmlwf).
 
 Using `DESTDIR` is supported.  It works as follows:
 
 ```console
 make install DESTDIR=/path/to/image
 ```
 
 overrides the in-makefile set `DESTDIR`, because variable-setting priority is
 
 1. commandline
 1. in-makefile
 1. environment
 
 Note: This only applies to the Expat library itself, building UTF-16 versions
 of xmlwf and the tests is currently not supported.
 
 When using Expat with a project using autoconf for configuration, you
 can use the probing macro in `conftools/expat.m4` to determine how to
 include Expat.  See the comments at the top of that file for more
 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
+```
Index: vendor/expat/dist/configure.ac
===================================================================
--- vendor/expat/dist/configure.ac	(revision 355070)
+++ vendor/expat/dist/configure.ac	(revision 355071)
@@ -1,264 +1,319 @@
 dnl   configuration script for expat
 dnl   Process this file with autoconf to produce a configure script.
 dnl
 dnl   Copyright 2000 Clark Cooper
 dnl
 dnl   This file is part of EXPAT.
 dnl
 dnl   EXPAT is free software; you can redistribute it and/or modify it
 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
 dnl symbol holding the correct version number. AC_INIT() requires the
 dnl version number at m4-time, rather than when ./configure is run, so
 dnl all this must happen as part of m4, not as part of the shell code
 dnl contained in ./configure.
 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
 dnl Increment LIBREVISION if source code has changed at all
 dnl
 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
+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++])
 
-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
+AS_IF([test "$GCC" = yes],
+  [AX_APPEND_LINK_FLAGS([-fno-strict-aliasing],[LDFLAGS])])
 
-    CFLAGS="${CFLAGS} -fno-strict-aliasing"
-    CXXFLAGS="${CXXFLAGS} -fno-strict-aliasing"
-    LDFLAGS="${LDFLAGS} -fno-strict-aliasing"
-fi
+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])
+    #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() {
+   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_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])
 
-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" != 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_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_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)
 
 
 dnl Some basic configuration:
 AC_DEFINE([XML_NS], 1,
           [Define to make XML Namespaces functionality available.])
 AC_DEFINE([XML_DTD], 1,
           [Define to make parameter entity parsing functionality available.])
 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.])
-])
+    [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@:>@])
+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])
 
 AC_ARG_VAR([DOCBOOK_TO_MAN], [docbook2x-man command])
 AS_IF([test "x$with_docbook" != xno],
   [AC_CHECK_PROGS([DOCBOOK_TO_MAN], [docbook2x-man db2x_docbook2man docbook2man docbook-to-man])])
 AS_IF([test "x${DOCBOOK_TO_MAN}" = x -a "x$with_docbook" = xyes],
   [AC_MSG_ERROR([Required program 'docbook2x-man' not found.])])
 AS_IF([test "x${DOCBOOK_TO_MAN}" != x -a "x$with_docbook" != xno],
   [AS_IF([${DOCBOOK_TO_MAN} --help | grep -i -q -F sgmlbase],
     [AC_MSG_ERROR([Your local ${DOCBOOK_TO_MAN} was found to work with SGML rather
   than XML. Please install docbook2X and use variable DOCBOOK_TO_MAN to point
   configure to command docbook2x-man of docbook2X.
   Or use DOCBOOK_TO_MAN="xmlto man --skip-validation" if you have xmlto around.
   You can also configure using --without-docbook if you can do without a man
   page for xmlwf.])])])
 
 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
Index: vendor/expat/dist/doc/Makefile.am
===================================================================
--- vendor/expat/dist/doc/Makefile.am	(revision 355070)
+++ vendor/expat/dist/doc/Makefile.am	(revision 355071)
@@ -1,56 +1,59 @@
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
+.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
 
 # https://www.gnu.org/software/automake/manual/automake.html#What-Gets-Cleaned
 .PHONY: clean-local
 clean-local: clean-local-check
 
 .PHONY: clean-local-check
 clean-local-check:
 	$(RM) xmlwf.1
 
 EXTRA_DIST = \
     expat.png \
     reference.html \
     style.css \
     valid-xhtml10.png \
     xmlwf.xml
Index: vendor/expat/dist/doc/Makefile.in
===================================================================
--- vendor/expat/dist/doc/Makefile.in	(revision 355070)
+++ vendor/expat/dist/doc/Makefile.in	(revision 355071)
@@ -1,579 +1,596 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 subdir = doc
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 am__v_at_0 = @
 am__v_at_1 = 
 SOURCES =
 DIST_SOURCES =
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     *) f=$$p;; \
   esac;
 am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
 am__install_max = 40
 am__nobase_strip_setup = \
   srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
 am__nobase_strip = \
   for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
 am__nobase_list = $(am__nobase_strip_setup); \
   for p in $$list; do echo "$$p $$p"; done | \
   sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
   $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
     if (++n[$$2] == $(am__install_max)) \
       { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
     END { for (dir in files) print dir, files[dir] }'
 am__base_list = \
   sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
   sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
 am__uninstall_files_from_dir = { \
   test -z "$$files" \
     || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
     || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
 man1dir = $(mandir)/man1
 am__installdirs = "$(DESTDIR)$(man1dir)"
 NROFF = nroff
 MANS = $(dist_man_MANS)
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP)
 am__DIST_COMMON = $(dist_man_MANS) $(srcdir)/Makefile.in
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 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 \
     style.css \
     valid-xhtml10.png \
     xmlwf.xml
 
 all: all-am
 
 .SUFFIXES:
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu doc/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu doc/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 install-man1: $(dist_man_MANS)
 	@$(NORMAL_INSTALL)
 	@list1=''; \
 	list2='$(dist_man_MANS)'; \
 	test -n "$(man1dir)" \
 	  && test -n "`echo $$list1$$list2`" \
 	  || exit 0; \
 	echo " $(MKDIR_P) '$(DESTDIR)$(man1dir)'"; \
 	$(MKDIR_P) "$(DESTDIR)$(man1dir)" || exit 1; \
 	{ for i in $$list1; do echo "$$i"; done;  \
 	if test -n "$$list2"; then \
 	  for i in $$list2; do echo "$$i"; done \
 	    | sed -n '/\.1[a-z]*$$/p'; \
 	fi; \
 	} | while read p; do \
 	  if test -f $$p; then d=; else d="$(srcdir)/"; fi; \
 	  echo "$$d$$p"; echo "$$p"; \
 	done | \
 	sed -e 'n;s,.*/,,;p;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
 	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,' | \
 	sed 'N;N;s,\n, ,g' | { \
 	list=; while read file base inst; do \
 	  if test "$$base" = "$$inst"; then list="$$list $$file"; else \
 	    echo " $(INSTALL_DATA) '$$file' '$(DESTDIR)$(man1dir)/$$inst'"; \
 	    $(INSTALL_DATA) "$$file" "$(DESTDIR)$(man1dir)/$$inst" || exit $$?; \
 	  fi; \
 	done; \
 	for i in $$list; do echo "$$i"; done | $(am__base_list) | \
 	while read files; do \
 	  test -z "$$files" || { \
 	    echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(man1dir)'"; \
 	    $(INSTALL_DATA) $$files "$(DESTDIR)$(man1dir)" || exit $$?; }; \
 	done; }
 
 uninstall-man1:
 	@$(NORMAL_UNINSTALL)
 	@list=''; test -n "$(man1dir)" || exit 0; \
 	files=`{ for i in $$list; do echo "$$i"; done; \
 	l2='$(dist_man_MANS)'; for i in $$l2; do echo "$$i"; done | \
 	  sed -n '/\.1[a-z]*$$/p'; \
 	} | sed -e 's,.*/,,;h;s,.*\.,,;s,^[^1][0-9a-z]*$$,1,;x' \
 	      -e 's,\.[0-9a-z]*$$,,;$(transform);G;s,\n,.,'`; \
 	dir='$(DESTDIR)$(man1dir)'; $(am__uninstall_files_from_dir)
 tags TAGS:
 
 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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || 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)
 installdirs:
 	for dir in "$(DESTDIR)$(man1dir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
 install: install-am
 install-exec: install-exec-am
 install-data: install-data-am
 uninstall: uninstall-am
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-am
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-am
 
 clean-am: clean-generic clean-libtool clean-local mostlyclean-am
 
 distclean: distclean-am
 	-rm -f Makefile
 distclean-am: clean-am distclean-generic
 
 dvi: dvi-am
 
 dvi-am:
 
 html: html-am
 
 html-am:
 
 info: info-am
 
 info-am:
 
 install-data-am: install-man
 
 install-dvi: install-dvi-am
 
 install-dvi-am:
 
 install-exec-am:
 
 install-html: install-html-am
 
 install-html-am:
 
 install-info: install-info-am
 
 install-info-am:
 
 install-man: install-man1
 
 install-pdf: install-pdf-am
 
 install-pdf-am:
 
 install-ps: install-ps-am
 
 install-ps-am:
 
 installcheck-am:
 
 maintainer-clean: maintainer-clean-am
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
 mostlyclean: mostlyclean-am
 
 mostlyclean-am: mostlyclean-generic mostlyclean-libtool
 
 pdf: pdf-am
 
 pdf-am:
 
 ps: ps-am
 
 ps-am:
 
 uninstall-am: uninstall-man
 
 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
 
 # https://www.gnu.org/software/automake/manual/automake.html#What-Gets-Cleaned
 .PHONY: clean-local
 clean-local: clean-local-check
 
 .PHONY: clean-local-check
 clean-local-check:
 	$(RM) xmlwf.1
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/doc/reference.html
===================================================================
--- vendor/expat/dist/doc/reference.html	(revision 355070)
+++ vendor/expat/dist/doc/reference.html	(revision 355071)
@@ -1,2394 +1,2396 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
                       "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
 <head>
 <!-- Copyright 1999,2000 Clark Cooper <coopercc@netheaven.com>
      All rights reserved.
      This is free software. You may distribute or modify according to
      the terms of the MIT/X License -->
   <title>Expat XML Parser</title>
   <meta name="author" content="Clark Cooper, coopercc@netheaven.com" />
   <meta http-equiv="Content-Style-Type" content="text/css" />
   <link href="style.css" rel="stylesheet" type="text/css" />
 </head>
 <body>
   <table cellspacing="0" cellpadding="0" width="100%">
     <tr>
       <td class="corner"><img src="expat.png" alt="(Expat logo)" /></td>
       <td class="banner"><h1>The Expat XML Parser</h1></td>
     </tr>
     <tr>
       <td class="releaseno">Release 2.0.1</td>
       <td></td>
     </tr>
   </table>
 <div class="content">
 
 <p>Expat is a library, written in C, for parsing XML documents. It's
 the underlying XML parser for the open source Mozilla project, Perl's
 <code>XML::Parser</code>, Python's <code>xml.parsers.expat</code>, and
 other open-source XML parsers.</p>
 
 <p>This library is the creation of James Clark, who's also given us
 groff (an nroff look-alike), Jade (an implementation of ISO's DSSSL
 stylesheet language for SGML), XP (a Java XML parser package), XT (a
 Java XSL engine).  James was also the technical lead on the XML
 Working Group at W3C that produced the XML specification.</p>
 
 <p>This is free software, licensed under the <a
 href="../COPYING">MIT/X Consortium license</a>. You may download it
 from <a href="http://www.libexpat.org/">the Expat home page</a>.
 </p>
 
 <p>The bulk of this document was originally commissioned as an article
 by <a href="http://www.xml.com/">XML.com</a>. They graciously allowed
 Clark Cooper to retain copyright and to distribute it with Expat.
 This version has been substantially extended to include documentation
 on features which have been added since the original article was
 published, and additional information on using the original
 interface.</p>
 
 <hr />
 <h2>Table of Contents</h2>
 <ul>
   <li><a href="#overview">Overview</a></li>
   <li><a href="#building">Building and Installing</a></li>
   <li><a href="#using">Using Expat</a></li>
   <li><a href="#reference">Reference</a>
   <ul>
     <li><a href="#creation">Parser Creation Functions</a>
     <ul>
       <li><a href="#XML_ParserCreate">XML_ParserCreate</a></li>
       <li><a href="#XML_ParserCreateNS">XML_ParserCreateNS</a></li>
       <li><a href="#XML_ParserCreate_MM">XML_ParserCreate_MM</a></li>
       <li><a href="#XML_ExternalEntityParserCreate">XML_ExternalEntityParserCreate</a></li>
       <li><a href="#XML_ParserFree">XML_ParserFree</a></li>
       <li><a href="#XML_ParserReset">XML_ParserReset</a></li>
     </ul>
     </li>
     <li><a href="#parsing">Parsing Functions</a>
     <ul>
       <li><a href="#XML_Parse">XML_Parse</a></li>
       <li><a href="#XML_ParseBuffer">XML_ParseBuffer</a></li>
       <li><a href="#XML_GetBuffer">XML_GetBuffer</a></li>
       <li><a href="#XML_StopParser">XML_StopParser</a></li>
       <li><a href="#XML_ResumeParser">XML_ResumeParser</a></li>
       <li><a href="#XML_GetParsingStatus">XML_GetParsingStatus</a></li>
     </ul>
     </li>
     <li><a href="#setting">Handler Setting Functions</a>
     <ul>
       <li><a href="#XML_SetStartElementHandler">XML_SetStartElementHandler</a></li>
       <li><a href="#XML_SetEndElementHandler">XML_SetEndElementHandler</a></li>
       <li><a href="#XML_SetElementHandler">XML_SetElementHandler</a></li>
       <li><a href="#XML_SetCharacterDataHandler">XML_SetCharacterDataHandler</a></li>
       <li><a href="#XML_SetProcessingInstructionHandler">XML_SetProcessingInstructionHandler</a></li>
       <li><a href="#XML_SetCommentHandler">XML_SetCommentHandler</a></li>
       <li><a href="#XML_SetStartCdataSectionHandler">XML_SetStartCdataSectionHandler</a></li>
       <li><a href="#XML_SetEndCdataSectionHandler">XML_SetEndCdataSectionHandler</a></li>
       <li><a href="#XML_SetCdataSectionHandler">XML_SetCdataSectionHandler</a></li>
       <li><a href="#XML_SetDefaultHandler">XML_SetDefaultHandler</a></li>
       <li><a href="#XML_SetDefaultHandlerExpand">XML_SetDefaultHandlerExpand</a></li>
       <li><a href="#XML_SetExternalEntityRefHandler">XML_SetExternalEntityRefHandler</a></li>
       <li><a href="#XML_SetExternalEntityRefHandlerArg">XML_SetExternalEntityRefHandlerArg</a></li>
       <li><a href="#XML_SetSkippedEntityHandler">XML_SetSkippedEntityHandler</a></li>
       <li><a href="#XML_SetUnknownEncodingHandler">XML_SetUnknownEncodingHandler</a></li>
       <li><a href="#XML_SetStartNamespaceDeclHandler">XML_SetStartNamespaceDeclHandler</a></li>
       <li><a href="#XML_SetEndNamespaceDeclHandler">XML_SetEndNamespaceDeclHandler</a></li>
       <li><a href="#XML_SetNamespaceDeclHandler">XML_SetNamespaceDeclHandler</a></li>
       <li><a href="#XML_SetXmlDeclHandler">XML_SetXmlDeclHandler</a></li>		  
       <li><a href="#XML_SetStartDoctypeDeclHandler">XML_SetStartDoctypeDeclHandler</a></li>
       <li><a href="#XML_SetEndDoctypeDeclHandler">XML_SetEndDoctypeDeclHandler</a></li>
       <li><a href="#XML_SetDoctypeDeclHandler">XML_SetDoctypeDeclHandler</a></li>
       <li><a href="#XML_SetElementDeclHandler">XML_SetElementDeclHandler</a></li>
       <li><a href="#XML_SetAttlistDeclHandler">XML_SetAttlistDeclHandler</a></li>
       <li><a href="#XML_SetEntityDeclHandler">XML_SetEntityDeclHandler</a></li>
       <li><a href="#XML_SetUnparsedEntityDeclHandler">XML_SetUnparsedEntityDeclHandler</a></li>
       <li><a href="#XML_SetNotationDeclHandler">XML_SetNotationDeclHandler</a></li>
       <li><a href="#XML_SetNotStandaloneHandler">XML_SetNotStandaloneHandler</a></li>
     </ul>
     </li>
     <li><a href="#position">Parse Position and Error Reporting Functions</a>
     <ul>
       <li><a href="#XML_GetErrorCode">XML_GetErrorCode</a></li>
       <li><a href="#XML_ErrorString">XML_ErrorString</a></li>
       <li><a href="#XML_GetCurrentByteIndex">XML_GetCurrentByteIndex</a></li>
       <li><a href="#XML_GetCurrentLineNumber">XML_GetCurrentLineNumber</a></li>
       <li><a href="#XML_GetCurrentColumnNumber">XML_GetCurrentColumnNumber</a></li>
       <li><a href="#XML_GetCurrentByteCount">XML_GetCurrentByteCount</a></li>
       <li><a href="#XML_GetInputContext">XML_GetInputContext</a></li>
     </ul>
     </li>
     <li><a href="#miscellaneous">Miscellaneous Functions</a>
     <ul>
       <li><a href="#XML_SetUserData">XML_SetUserData</a></li>
       <li><a href="#XML_GetUserData">XML_GetUserData</a></li>
       <li><a href="#XML_UseParserAsHandlerArg">XML_UseParserAsHandlerArg</a></li>
       <li><a href="#XML_SetBase">XML_SetBase</a></li>
       <li><a href="#XML_GetBase">XML_GetBase</a></li>
       <li><a href="#XML_GetSpecifiedAttributeCount">XML_GetSpecifiedAttributeCount</a></li>
       <li><a href="#XML_GetIdAttributeIndex">XML_GetIdAttributeIndex</a></li>
       <li><a href="#XML_GetAttributeInfo">XML_GetAttributeInfo</a></li>
       <li><a href="#XML_SetEncoding">XML_SetEncoding</a></li>
       <li><a href="#XML_SetParamEntityParsing">XML_SetParamEntityParsing</a></li>
       <li><a href="#XML_SetHashSalt">XML_SetHashSalt</a></li>
       <li><a href="#XML_UseForeignDTD">XML_UseForeignDTD</a></li>
       <li><a href="#XML_SetReturnNSTriplet">XML_SetReturnNSTriplet</a></li>
       <li><a href="#XML_DefaultCurrent">XML_DefaultCurrent</a></li>
       <li><a href="#XML_ExpatVersion">XML_ExpatVersion</a></li>
       <li><a href="#XML_ExpatVersionInfo">XML_ExpatVersionInfo</a></li>
       <li><a href="#XML_GetFeatureList">XML_GetFeatureList</a></li>
       <li><a href="#XML_FreeContentModel">XML_FreeContentModel</a></li>
       <li><a href="#XML_MemMalloc">XML_MemMalloc</a></li>
       <li><a href="#XML_MemRealloc">XML_MemRealloc</a></li>
       <li><a href="#XML_MemFree">XML_MemFree</a></li>
     </ul>
     </li>
   </ul>  
   </li>
 </ul>
 
 <hr />
 <h2><a name="overview">Overview</a></h2>
 
 <p>Expat is a stream-oriented parser. You register callback (or
 handler) functions with the parser and then start feeding it the
 document.  As the parser recognizes parts of the document, it will
 call the appropriate handler for that part (if you've registered one.) 
 The document is fed to the parser in pieces, so you can start parsing
 before you have all the document. This also allows you to parse really
 huge documents that won't fit into memory.</p>
 
 <p>Expat can be intimidating due to the many kinds of handlers and
 options you can set. But you only need to learn four functions in
 order to do 90% of what you'll want to do with it:</p>
 
 <dl>
 
 <dt><code><a href= "#XML_ParserCreate"
              >XML_ParserCreate</a></code></dt>
   <dd>Create a new parser object.</dd>
 
 <dt><code><a href= "#XML_SetElementHandler"
              >XML_SetElementHandler</a></code></dt>
   <dd>Set handlers for start and end tags.</dd>
 
 <dt><code><a href= "#XML_SetCharacterDataHandler"
              >XML_SetCharacterDataHandler</a></code></dt>
   <dd>Set handler for text.</dd>
 
 <dt><code><a href= "#XML_Parse"
              >XML_Parse</a></code></dt>
   <dd>Pass a buffer full of document to the parser</dd>
 </dl>
 
 <p>These functions and others are described in the <a
 href="#reference">reference</a> part of this document. The reference
 section also describes in detail the parameters passed to the
 different types of handlers.</p>
 
 <p>Let's look at a very simple example program that only uses 3 of the
 above functions (it doesn't need to set a character handler.) The
 program <a href="../examples/outline.c">outline.c</a> prints an
 element outline, indenting child elements to distinguish them from the
 parent element that contains them. The start handler does all the
 work.  It prints two indenting spaces for every level of ancestor
 elements, then it prints the element and attribute
 information. Finally it increments the global <code>Depth</code>
 variable.</p>
 
 <pre class="eg">
 int Depth;
 
 void XMLCALL
 start(void *data, const char *el, const char **attr) {
   int i;
 
   for (i = 0; i &lt; Depth; i++)
     printf("  ");
 
   printf("%s", el);
 
   for (i = 0; attr[i]; i += 2) {
     printf(" %s='%s'", attr[i], attr[i + 1]);
   }
 
   printf("\n");
   Depth++;
 }  /* End of start handler */
 </pre>
 
 <p>The end tag simply does the bookkeeping work of decrementing
 <code>Depth</code>.</p>
 <pre class="eg">
 void XMLCALL
 end(void *data, const char *el) {
   Depth--;
 }  /* End of end handler */
 </pre>
 
 <p>Note the <code>XMLCALL</code> annotation used for the callbacks.
 This is used to ensure that the Expat and the callbacks are using the
 same calling convention in case the compiler options used for Expat
 itself and the client code are different.  Expat tries not to care
 what the default calling convention is, though it may require that it
 be compiled with a default convention of "cdecl" on some platforms.
 For code which uses Expat, however, the calling convention is
 specified by the <code>XMLCALL</code> annotation on most platforms;
 callbacks should be defined using this annotation.</p>
 
 <p>The <code>XMLCALL</code> annotation was added in Expat 1.95.7, but
 existing working Expat applications don't need to add it (since they
 are already using the "cdecl" calling convention, or they wouldn't be
 working).  The annotation is only needed if the default calling
 convention may be something other than "cdecl".  To use the annotation
 safely with older versions of Expat, you can conditionally define it
 <em>after</em> including Expat's header file:</p>
 
 <pre class="eg">
 #include &lt;expat.h&gt;
 
 #ifndef XMLCALL
 #if defined(_MSC_EXTENSIONS) &amp;&amp; !defined(__BEOS__) &amp;&amp; !defined(__CYGWIN__)
 #define XMLCALL __cdecl
 #elif defined(__GNUC__)
 #define XMLCALL __attribute__((cdecl))
 #else
 #define XMLCALL
 #endif
 #endif
 </pre>
 
 <p>After creating the parser, the main program just has the job of
 shoveling the document to the parser so that it can do its work.</p>
 
 <hr />
 <h2><a name="building">Building and Installing Expat</a></h2>
 
 <p>The Expat distribution comes as a compressed (with GNU gzip) tar
 file.  You may download the latest version from <a href=
 "http://sourceforge.net/projects/expat/" >Source Forge</a>.  After
 unpacking this, cd into the directory. Then follow either the Win32
 directions or Unix directions below.</p>
 
 <h3>Building under Win32</h3>
 
 <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>
 
 <h3>Building under Unix (or GNU)</h3>
 
 <p>First you'll need to run the configure shell script in order to
 configure the Makefiles and headers for your system.</p>
 
 <p>If you're happy with all the defaults that configure picks for you,
 and you have permission on your system to install into /usr/local, you
 can install Expat with this sequence of commands:</p>
 
 <pre class="eg">
 ./configure
 make
 make install
 </pre>
 
 <p>There are some options that you can provide to this script, but the
 only one we'll mention here is the <code>--prefix</code> option. You
 can find out all the options available by running configure with just
 the <code>--help</code> option.</p>
 
 <p>By default, the configure script sets things up so that the library
 gets installed in <code>/usr/local/lib</code> and the associated
 header file in <code>/usr/local/include</code>.  But if you were to
 give the option, <code>--prefix=/home/me/mystuff</code>, then the
 library and header would get installed in
 <code>/home/me/mystuff/lib</code> and
 <code>/home/me/mystuff/include</code> respectively.</p>
 
 <h3>Configuring Expat Using the Pre-Processor</h3>
 
 <p>Expat's feature set can be configured using a small number of
 pre-processor definitions.  The definition of this symbols does not
 affect the set of entry points for Expat, only the behavior of the API
 and the definition of character types in the case of
 <code>XML_UNICODE_WCHAR_T</code>.  The symbols are:</p>
 
 <dl class="cpp-symbols">
 <dt>XML_DTD</dt>
 <dd>Include support for using and reporting DTD-based content.  If
 this is defined, default attribute values from an external DTD subset
 are reported and attribute value normalization occurs based on the
 type of attributes defined in the external subset.  Without
 this, Expat has a smaller memory footprint and can be faster, but will
 not load external entities or process conditional sections.  This does
 not affect the set of functions available in the API.</dd>
 
 <dt>XML_NS</dt>
 <dd>When defined, support for the <cite><a href=
 "http://www.w3.org/TR/REC-xml-names/" >Namespaces in XML</a></cite>
 specification is included.</dd>
 
 <dt>XML_UNICODE</dt>
 <dd>When defined, character data reported to the application is
 encoded in UTF-16 using wide characters of the type
 <code>XML_Char</code>.  This is implied if
 <code>XML_UNICODE_WCHAR_T</code> is defined.</dd>
 
 <dt>XML_UNICODE_WCHAR_T</dt>
 <dd>If defined, causes the <code>XML_Char</code> character type to be
 defined using the <code>wchar_t</code> type; otherwise, <code>unsigned
 short</code> is used.  Defining this implies
 <code>XML_UNICODE</code>.</dd>
 
 <dt>XML_LARGE_SIZE</dt>
 <dd>If defined, causes the <code>XML_Size</code> and <code>XML_Index</code>
 integer types to be at least 64 bits in size. This is intended to support
 processing of very large input streams, where the return values of
 <code><a href="#XML_GetCurrentByteIndex" >XML_GetCurrentByteIndex</a></code>,
 <code><a href="#XML_GetCurrentLineNumber" >XML_GetCurrentLineNumber</a></code> and
 <code><a href="#XML_GetCurrentColumnNumber" >XML_GetCurrentColumnNumber</a></code>
 could overflow. It may not be supported by all compilers, and is turned
 off by default.</dd>
 
 <dt>XML_CONTEXT_BYTES</dt>
 <dd>The number of input bytes of markup context which the parser will
 ensure are available for reporting via <code><a href=
 "#XML_GetInputContext" >XML_GetInputContext</a></code>.  This is
 normally set to 1024, and must be set to a positive integer.  If this
 is not defined, the input context will not be available and <code><a
 href= "#XML_GetInputContext" >XML_GetInputContext</a></code> will
 always report NULL.  Without this, Expat has a smaller memory
 footprint and can be faster.</dd>
 
 <dt>XML_STATIC</dt>
 <dd>On Windows, this should be set if Expat is going to be linked
 statically with the code that calls it; this is required to get all
 the right MSVC magic annotations correct.  This is ignored on other
 platforms.</dd>
 
 <dt>XML_ATTR_INFO</dt>
 <dd>If defined, makes the additional function <code><a href=
 "#XML_GetAttributeInfo" >XML_GetAttributeInfo</a></code> available
 for reporting attribute byte offsets.</dd>
 </dl>
 
 <hr />
 <h2><a name="using">Using Expat</a></h2>
 
 <h3>Compiling and Linking Against Expat</h3>
 
 <p>Unless you installed Expat in a location not expected by your
 compiler and linker, all you have to do to use Expat in your programs
 is to include the Expat header (<code>#include &lt;expat.h&gt;</code>)
 in your files that make calls to it and to tell the linker that it
 needs to link against the Expat library.  On Unix systems, this would
 usually be done with the <code>-lexpat</code> argument.  Otherwise,
 you'll need to tell the compiler where to look for the Expat header
 and the linker where to find the Expat library.  You may also need to
 take steps to tell the operating system where to find this library at
 run time.</p>
 
 <p>On a Unix-based system, here's what a Makefile might look like when
 Expat is installed in a standard location:</p>
 
 <pre class="eg">
 CC=cc
 LDFLAGS=
 LIBS= -lexpat
 xmlapp: xmlapp.o
         $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS)
 </pre>
 
 <p>If you installed Expat in, say, <code>/home/me/mystuff</code>, then
 the Makefile would look like this:</p>
 
 <pre class="eg">
 CC=cc
 CFLAGS= -I/home/me/mystuff/include
 LDFLAGS=
 LIBS= -L/home/me/mystuff/lib -lexpat
 xmlapp: xmlapp.o
         $(CC) $(LDFLAGS) -o xmlapp xmlapp.o $(LIBS)
 </pre>
 
 <p>You'd also have to set the environment variable
 <code>LD_LIBRARY_PATH</code> to <code>/home/me/mystuff/lib</code> (or
 to <code>${LD_LIBRARY_PATH}:/home/me/mystuff/lib</code> if
 LD_LIBRARY_PATH already has some directories in it) in order to run
 your application.</p>
 
 <h3>Expat Basics</h3>
 
 <p>As we saw in the example in the overview, the first step in parsing
 an XML document with Expat is to create a parser object. There are <a
 href="#creation">three functions</a> in the Expat API for creating a
 parser object.  However, only two of these (<code><a href=
 "#XML_ParserCreate" >XML_ParserCreate</a></code> and <code><a href=
 "#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>) can be used for
 constructing a parser for a top-level document.  The object returned
 by these functions is an opaque pointer (i.e. "expat.h" declares it as
 void *) to data with further internal structure. In order to free the
 memory associated with this object you must call <code><a href=
 "#XML_ParserFree" >XML_ParserFree</a></code>. Note that if you have
 provided any <a href="#userdata">user data</a> that gets stored in the
 parser, then your application is responsible for freeing it prior to
 calling <code>XML_ParserFree</code>.</p>
 
 <p>The objects returned by the parser creation functions are good for
 parsing only one XML document or external parsed entity. If your
 application needs to parse many XML documents, then it needs to create
 a parser object for each one. The best way to deal with this is to
 create a higher level object that contains all the default
 initialization you want for your parser objects.</p>
 
 <p>Walking through a document hierarchy with a stream oriented parser
 will require a good stack mechanism in order to keep track of current
 context.  For instance, to answer the simple question, "What element
 does this text belong to?" requires a stack, since the parser may have
 descended into other elements that are children of the current one and
 has encountered this text on the way out.</p>
 
 <p>The things you're likely to want to keep on a stack are the
 currently opened element and it's attributes. You push this
 information onto the stack in the start handler and you pop it off in
 the end handler.</p>
 
 <p>For some tasks, it is sufficient to just keep information on what
 the depth of the stack is (or would be if you had one.) The outline
 program shown above presents one example. Another such task would be
 skipping over a complete element. When you see the start tag for the
 element you want to skip, you set a skip flag and record the depth at
 which the element started.  When the end tag handler encounters the
 same depth, the skipped element has ended and the flag may be
 cleared. If you follow the convention that the root element starts at
 1, then you can use the same variable for skip flag and skip
 depth.</p>
 
 <pre class="eg">
 void
 init_info(Parseinfo *info) {
   info->skip = 0;
   info->depth = 1;
   /* Other initializations here */
 }  /* End of init_info */
 
 void XMLCALL
 rawstart(void *data, const char *el, const char **attr) {
   Parseinfo *inf = (Parseinfo *) data;
 
   if (! inf->skip) {
     if (should_skip(inf, el, attr)) {
       inf->skip = inf->depth;
     }
     else
       start(inf, el, attr);     /* This does rest of start handling */
   }
 
   inf->depth++;
 }  /* End of rawstart */
 
 void XMLCALL
 rawend(void *data, const char *el) {
   Parseinfo *inf = (Parseinfo *) data;
 
   inf->depth--;
 
   if (! inf->skip)
     end(inf, el);              /* This does rest of end handling */
 
   if (inf->skip == inf->depth)
     inf->skip = 0;
 }  /* End rawend */
 </pre>
 
 <p>Notice in the above example the difference in how depth is
 manipulated in the start and end handlers. The end tag handler should
 be the mirror image of the start tag handler. This is necessary to
 properly model containment. Since, in the start tag handler, we
 incremented depth <em>after</em> the main body of start tag code, then
 in the end handler, we need to manipulate it <em>before</em> the main
 body.  If we'd decided to increment it first thing in the start
 handler, then we'd have had to decrement it last thing in the end
 handler.</p>
 
 <h3 id="userdata">Communicating between handlers</h3>
 
 <p>In order to be able to pass information between different handlers
 without using globals, you'll need to define a data structure to hold
 the shared variables. You can then tell Expat (with the <code><a href=
 "#XML_SetUserData" >XML_SetUserData</a></code> function) to pass a
 pointer to this structure to the handlers.  This is the first
 argument received by most handlers.  In the <a href="#reference"
 >reference section</a>, an argument to a callback function is named
 <code>userData</code> and have type <code>void *</code> if the user
 data is passed; it will have the type <code>XML_Parser</code> if the
 parser itself is passed.  When the parser is passed, the user data may
 be retrieved using <code><a href="#XML_GetUserData"
 >XML_GetUserData</a></code>.</p>
 
 <p>One common case where multiple calls to a single handler may need
 to communicate using an application data structure is the case when
 content passed to the character data handler (set by <code><a href=
 "#XML_SetCharacterDataHandler"
 >XML_SetCharacterDataHandler</a></code>) needs to be accumulated.  A
 common first-time mistake with any of the event-oriented interfaces to
 an XML parser is to expect all the text contained in an element to be
 reported by a single call to the character data handler.  Expat, like
 many other XML parsers, reports such data as a sequence of calls;
 there's no way to know when the end of the sequence is reached until a
 different callback is made.  A buffer referenced by the user data
 structure proves both an effective and convenient place to accumulate
 character data.</p>
 
 <!-- XXX example needed here -->
 
 
 <h3>XML Version</h3>
 
 <p>Expat is an XML 1.0 parser, and as such never complains based on
 the value of the <code>version</code> pseudo-attribute in the XML
 declaration, if present.</p>
 
 <p>If an application needs to check the version number (to support
 alternate processing), it should use the <code><a href=
 "#XML_SetXmlDeclHandler" >XML_SetXmlDeclHandler</a></code> function to
 set a handler that uses the information in the XML declaration to
 determine what to do.  This example shows how to check that only a
 version number of <code>"1.0"</code> is accepted:</p>
 
 <pre class="eg">
 static int wrong_version;
 static XML_Parser parser;
 
 static void XMLCALL
 xmldecl_handler(void            *userData,
                 const XML_Char  *version,
                 const XML_Char  *encoding,
                 int              standalone)
 {
   static const XML_Char Version_1_0[] = {'1', '.', '0', 0};
 
   int i;
 
   for (i = 0; i &lt; (sizeof(Version_1_0) / sizeof(Version_1_0[0])); ++i) {
     if (version[i] != Version_1_0[i]) {
       wrong_version = 1;
       /* also clear all other handlers: */
       XML_SetCharacterDataHandler(parser, NULL);
       ...
       return;
     }
   }
   ...
 }
 </pre>
 
 <h3>Namespace Processing</h3>
 
 <p>When the parser is created using the <code><a href=
 "#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>, function, Expat
 performs namespace processing. Under namespace processing, Expat
 consumes <code>xmlns</code> and <code>xmlns:...</code> attributes,
 which declare namespaces for the scope of the element in which they
 occur. This means that your start handler will not see these
 attributes.  Your application can still be informed of these
 declarations by setting namespace declaration handlers with <a href=
 "#XML_SetNamespaceDeclHandler"
 ><code>XML_SetNamespaceDeclHandler</code></a>.</p>
 
 <p>Element type and attribute names that belong to a given namespace
 are passed to the appropriate handler in expanded form. By default
 this expanded form is a concatenation of the namespace URI, the
 separator character (which is the 2nd argument to <code><a href=
 "#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>), and the local
 name (i.e. the part after the colon). Names with undeclared prefixes
 are not well-formed when namespace processing is enabled, and will
 trigger an error. Unprefixed attribute names are never expanded,
 and unprefixed element names are only expanded when they are in the
 scope of a default namespace.</p>
 
 <p>However if <code><a href= "#XML_SetReturnNSTriplet"
 >XML_SetReturnNSTriplet</a></code> has been called with a non-zero
 <code>do_nst</code> parameter, then the expanded form for names with
 an explicit prefix is a concatenation of: URI, separator, local name,
 separator, prefix.</p>
 
 <p>You can set handlers for the start of a namespace declaration and
 for the end of a scope of a declaration with the <code><a href=
 "#XML_SetNamespaceDeclHandler" >XML_SetNamespaceDeclHandler</a></code>
 function.  The StartNamespaceDeclHandler is called prior to the start
 tag handler and the EndNamespaceDeclHandler is called after the
 corresponding end tag that ends the namespace's scope.  The namespace
 start handler gets passed the prefix and URI for the namespace.  For a
 default namespace declaration (xmlns='...'), the prefix will be null.
 The URI will be null for the case where the default namespace is being
 unset.  The namespace end handler just gets the prefix for the closing
 scope.</p>
 
 <p>These handlers are called for each declaration. So if, for
 instance, a start tag had three namespace declarations, then the
 StartNamespaceDeclHandler would be called three times before the start
 tag handler is called, once for each declaration.</p>
 
 <h3>Character Encodings</h3>
 
 <p>While XML is based on Unicode, and every XML processor is required
 to recognized UTF-8 and UTF-16 (1 and 2 byte encodings of Unicode),
 other encodings may be declared in XML documents or entities. For the
 main document, an XML declaration may contain an encoding
 declaration:</p>
 <pre>
 &lt;?xml version="1.0" encoding="ISO-8859-2"?&gt;
 </pre>
 
 <p>External parsed entities may begin with a text declaration, which
 looks like an XML declaration with just an encoding declaration:</p>
 <pre>
 &lt;?xml encoding="Big5"?&gt;
 </pre>
 
 <p>With Expat, you may also specify an encoding at the time of
 creating a parser. This is useful when the encoding information may
 come from a source outside the document itself (like a higher level
 protocol.)</p>
 
 <p><a name="builtin_encodings"></a>There are four built-in encodings
 in Expat:</p>
 <ul>
 <li>UTF-8</li>
 <li>UTF-16</li>
 <li>ISO-8859-1</li>
 <li>US-ASCII</li>
 </ul>
 
 <p>Anything else discovered in an encoding declaration or in the
 protocol encoding specified in the parser constructor, triggers a call
 to the <code>UnknownEncodingHandler</code>. This handler gets passed
 the encoding name and a pointer to an <code>XML_Encoding</code> data
 structure. Your handler must fill in this structure and return
 <code>XML_STATUS_OK</code> if it knows how to deal with the
 encoding. Otherwise the handler should return
 <code>XML_STATUS_ERROR</code>.  The handler also gets passed a pointer
 to an optional application data structure that you may indicate when
 you set the handler.</p>
 
 <p>Expat places restrictions on character encodings that it can
 support by filling in the <code>XML_Encoding</code> structure.
 include file:</p>
 <ol>
 <li>Every ASCII character that can appear in a well-formed XML document
 must be represented by a single byte, and that byte must correspond to
 it's ASCII encoding (except for the characters $@\^'{}~)</li>
 <li>Characters must be encoded in 4 bytes or less.</li>
 <li>All characters encoded must have Unicode scalar values less than or
 equal to 65535 (0xFFFF)<em>This does not apply to the built-in support
 for UTF-16 and UTF-8</em></li>
 <li>No character may be encoded by more that one distinct sequence of
 bytes</li>
 </ol>
 
 <p><code>XML_Encoding</code> contains an array of integers that
 correspond to the 1st byte of an encoding sequence. If the value in
 the array for a byte is zero or positive, then the byte is a single
 byte encoding that encodes the Unicode scalar value contained in the
 array. A -1 in this array indicates a malformed byte. If the value is
 -2, -3, or -4, then the byte is the beginning of a 2, 3, or 4 byte
 sequence respectively. Multi-byte sequences are sent to the convert
 function pointed at in the <code>XML_Encoding</code> structure. This
 function should return the Unicode scalar value for the sequence or -1
 if the sequence is malformed.</p>
 
 <p>One pitfall that novice Expat users are likely to fall into is that
 although Expat may accept input in various encodings, the strings that
 it passes to the handlers are always encoded in UTF-8 or UTF-16
 (depending on how Expat was compiled). Your application is responsible
 for any translation of these strings into other encodings.</p>
 
 <h3>Handling External Entity References</h3>
 
 <p>Expat does not read or parse external entities directly. Note that
 any external DTD is a special case of an external entity.  If you've
 set no <code>ExternalEntityRefHandler</code>, then external entity
 references are silently ignored. Otherwise, it calls your handler with
 the information needed to read and parse the external entity.</p>
 
 <p>Your handler isn't actually responsible for parsing the entity, but
 it is responsible for creating a subsidiary parser with <code><a href=
 "#XML_ExternalEntityParserCreate"
 >XML_ExternalEntityParserCreate</a></code> that will do the job. This
 returns an instance of <code>XML_Parser</code> that has handlers and
 other data structures initialized from the parent parser. You may then
 use <code><a href= "#XML_Parse" >XML_Parse</a></code> or <code><a
 href= "#XML_ParseBuffer">XML_ParseBuffer</a></code> calls against this
 parser.  Since external entities my refer to other external entities,
 your handler should be prepared to be called recursively.</p>
 
 <h3>Parsing DTDs</h3>
 
 <p>In order to parse parameter entities, before starting the parse,
 you must call <code><a href= "#XML_SetParamEntityParsing"
 >XML_SetParamEntityParsing</a></code> with one of the following
 arguments:</p>
 <dl>
 <dt><code>XML_PARAM_ENTITY_PARSING_NEVER</code></dt>
 <dd>Don't parse parameter entities or the external subset</dd>
 <dt><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></dt>
 <dd>Parse parameter entities and the external subset unless
 <code>standalone</code> was set to "yes" in the XML declaration.</dd>
 <dt><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></dt>
 <dd>Always parse parameter entities and the external subset</dd>
 </dl>
 
 <p>In order to read an external DTD, you also have to set an external
 entity reference handler as described above.</p>
 
 <h3 id="stop-resume">Temporarily Stopping Parsing</h3>
 
 <p>Expat 1.95.8 introduces a new feature: its now possible to stop
 parsing temporarily from within a handler function, even if more data
 has already been passed into the parser.  Applications for this
 include</p>
 
 <ul>
   <li>Supporting the <a href= "http://www.w3.org/TR/xinclude/"
   >XInclude</a> specification.</li>
 
   <li>Delaying further processing until additional information is
   available from some other source.</li>
 
   <li>Adjusting processor load as task priorities shift within an
   application.</li>
 
   <li>Stopping parsing completely (simply free or reset the parser
   instead of resuming in the outer parsing loop).  This can be useful
   if an application-domain error is found in the XML being parsed or if
   the result of the parse is determined not to be useful after
   all.</li>
 </ul>
 
 <p>To take advantage of this feature, the main parsing loop of an
 application needs to support this specifically.  It cannot be
 supported with a parsing loop compatible with Expat 1.95.7 or
 earlier (though existing loops will continue to work without
 supporting the stop/resume feature).</p>
 
 <p>An application that uses this feature for a single parser will have
 the rough structure (in pseudo-code):</p>
 
 <pre class="pseudocode">
 fd = open_input()
 p = create_parser()
 
 if parse_xml(p, fd) {
   /* suspended */
 
   int suspended = 1;
 
   while (suspended) {
     do_something_else()
     if ready_to_resume() {
       suspended = continue_parsing(p, fd);
     }
   }
 }
 </pre>
 
 <p>An application that may resume any of several parsers based on
 input (either from the XML being parsed or some other source) will
 certainly have more interesting control structures.</p>
 
 <p>This C function could be used for the <code>parse_xml</code>
 function mentioned in the pseudo-code above:</p>
 
 <pre class="eg">
 #define BUFF_SIZE 10240
 
 /* Parse a document from the open file descriptor 'fd' until the parse
    is complete (the document has been completely parsed, or there's
    been an error), or the parse is stopped.  Return non-zero when
    the parse is merely suspended.
 */
 int
 parse_xml(XML_Parser p, int fd)
 {
   for (;;) {
     int last_chunk;
     int bytes_read;
     enum XML_Status status;
 
     void *buff = XML_GetBuffer(p, BUFF_SIZE);
     if (buff == NULL) {
       /* handle error... */
       return 0;
     }
     bytes_read = read(fd, buff, BUFF_SIZE);
     if (bytes_read &lt; 0) {
       /* handle error... */
       return 0;
     }
     status = XML_ParseBuffer(p, bytes_read, bytes_read == 0);
     switch (status) {
       case XML_STATUS_ERROR:
         /* handle error... */
         return 0;
       case XML_STATUS_SUSPENDED:
         return 1;
     }
     if (bytes_read == 0)
       return 0;
   }
 }
 </pre>
 
 <p>The corresponding <code>continue_parsing</code> function is
 somewhat simpler, since it only need deal with the return code from
 <code><a href= "#XML_ResumeParser">XML_ResumeParser</a></code>; it can
 delegate the input handling to the <code>parse_xml</code>
 function:</p>
 
 <pre class="eg">
 /* Continue parsing a document which had been suspended.  The 'p' and
    'fd' arguments are the same as passed to parse_xml().  Return
    non-zero when the parse is suspended.
 */
 int
 continue_parsing(XML_Parser p, int fd)
 {
   enum XML_Status status = XML_ResumeParser(p);
   switch (status) {
     case XML_STATUS_ERROR:
       /* handle error... */
       return 0;
     case XML_ERROR_NOT_SUSPENDED:
       /* handle error... */
       return 0;.
     case XML_STATUS_SUSPENDED:
       return 1;
   }
   return parse_xml(p, fd);
 }
 </pre>
 
 <p>Now that we've seen what a mess the top-level parsing loop can
 become, what have we gained?  Very simply, we can now use the <code><a
 href= "#XML_StopParser" >XML_StopParser</a></code> function to stop
 parsing, without having to go to great lengths to avoid additional
 processing that we're expecting to ignore.  As a bonus, we get to stop
 parsing <em>temporarily</em>, and come back to it when we're
 ready.</p>
 
 <p>To stop parsing from a handler function, use the <code><a href=
 "#XML_StopParser" >XML_StopParser</a></code> function.  This function
 takes two arguments; the parser being stopped and a flag indicating
 whether the parse can be resumed in the future.</p>
 
 <!-- XXX really need more here -->
 
 
 <hr />
 <!-- ================================================================ -->
 
 <h2><a name="reference">Expat Reference</a></h2>
 
 <h3><a name="creation">Parser Creation</a></h3>
 
 <pre class="fcndec" id="XML_ParserCreate">
 XML_Parser XMLCALL
 XML_ParserCreate(const XML_Char *encoding);
 </pre>
 <div class="fcndef">
 Construct a new parser. If encoding is non-null, it specifies a
 character encoding to use for the document. This overrides the document
 encoding declaration. There are four built-in encodings:
 <ul>
 <li>US-ASCII</li>
 <li>UTF-8</li>
 <li>UTF-16</li>
 <li>ISO-8859-1</li>
 </ul>
 Any other value will invoke a call to the UnknownEncodingHandler.
 </div>
 
 <pre class="fcndec" id="XML_ParserCreateNS">
 XML_Parser XMLCALL
 XML_ParserCreateNS(const XML_Char *encoding,
                    XML_Char sep);
 </pre>
 <div class="fcndef">
 Constructs a new parser that has namespace processing in effect. Namespace
 expanded element names and attribute names are returned as a concatenation
 of the namespace URI, <em>sep</em>, and the local part of the name. This
 means that you should pick a character for <em>sep</em> that can't be part
 of an URI. Since Expat does not check namespace URIs for conformance, the
 only safe choice for a namespace separator is a character that is illegal
 in XML. For instance, <code>'\xFF'</code> is not legal in UTF-8, and
 <code>'\xFFFF'</code> is not legal in UTF-16. There is a special case when
 <em>sep</em> is the null character <code>'\0'</code>: the namespace URI and
 the local part will be concatenated without any separator - this is intended
 to support RDF processors. It is a programming error to use the null separator
 with <a href= "#XML_SetReturnNSTriplet">namespace triplets</a>.</div>
 
 <pre class="fcndec" id="XML_ParserCreate_MM">
 XML_Parser XMLCALL
 XML_ParserCreate_MM(const XML_Char *encoding,
                     const XML_Memory_Handling_Suite *ms,
 		    const XML_Char *sep);
 </pre>
 <pre class="signature">
 typedef struct {
   void *(XMLCALL *malloc_fcn)(size_t size);
   void *(XMLCALL *realloc_fcn)(void *ptr, size_t size);
   void (XMLCALL *free_fcn)(void *ptr);
 } XML_Memory_Handling_Suite;
 </pre>
 <div class="fcndef">
 <p>Construct a new parser using the suite of memory handling functions
 specified in <code>ms</code>. If <code>ms</code> is NULL, then use the
 standard set of memory management functions. If <code>sep</code> is
 non NULL, then namespace processing is enabled in the created parser
 and the character pointed at by sep is used as the separator between
 the namespace URI and the local part of the name.</p>
 </div>
 
 <pre class="fcndec" id="XML_ExternalEntityParserCreate">
 XML_Parser XMLCALL
 XML_ExternalEntityParserCreate(XML_Parser p,
                                const XML_Char *context,
                                const XML_Char *encoding);
 </pre>
 <div class="fcndef">
 Construct a new <code>XML_Parser</code> object for parsing an external
 general entity. Context is the context argument passed in a call to a
 ExternalEntityRefHandler. Other state information such as handlers,
 user data, namespace processing is inherited from the parser passed as
 the 1st argument. So you shouldn't need to call any of the behavior
 changing functions on this parser (unless you want it to act
 differently than the parent parser).
 </div>
 
 <pre class="fcndec" id="XML_ParserFree">
 void XMLCALL
 XML_ParserFree(XML_Parser p);
 </pre>
 <div class="fcndef">
 Free memory used by the parser. Your application is responsible for
 freeing any memory associated with <a href="#userdata">user data</a>.
 </div>
 
 <pre class="fcndec" id="XML_ParserReset">
 XML_Bool XMLCALL
 XML_ParserReset(XML_Parser p,
                 const XML_Char *encoding);
 </pre>
 <div class="fcndef">
 Clean up the memory structures maintained by the parser so that it may
 be used again.  After this has been called, <code>parser</code> is
 ready to start parsing a new document.  All handlers are cleared from
 the parser, except for the unknownEncodingHandler.  The parser's external
 state is re-initialized except for the values of ns and ns_triplets.
 This function may not be used on a parser created using <code><a href=
 "#XML_ExternalEntityParserCreate" >XML_ExternalEntityParserCreate</a
 ></code>; it will return <code>XML_FALSE</code> in that case.  Returns
 <code>XML_TRUE</code> on success.  Your application is responsible for
 dealing with any memory associated with <a href="#userdata">user data</a>.
 </div>
 
 <h3><a name="parsing">Parsing</a></h3>
 
 <p>To state the obvious: the three parsing functions <code><a href=
 "#XML_Parse" >XML_Parse</a></code>, <code><a href= "#XML_ParseBuffer">
 XML_ParseBuffer</a></code> and <code><a href= "#XML_GetBuffer">
 XML_GetBuffer</a></code> must not be called from within a handler
 unless they operate on a separate parser instance, that is, one that
 did not call the handler. For example, it is OK to call the parsing
 functions from within an <code>XML_ExternalEntityRefHandler</code>,
 if they apply to the parser created by
 <code><a href= "#XML_ExternalEntityParserCreate"
 >XML_ExternalEntityParserCreate</a></code>.</p>
 
 <p>Note: the <code>len</code> argument passed to these functions
 should be considerably less than the maximum value for an integer,
 as it could create an integer overflow situation if the added
 lengths of a buffer and the unprocessed portion of the previous buffer
 exceed the maximum integer value. Input data at the end of a buffer
 will remain unprocessed if it is part of an XML token for which the
 end is not part of that buffer.</p>
 
 <pre class="fcndec" id="XML_Parse">
 enum XML_Status XMLCALL
 XML_Parse(XML_Parser p,
           const char *s,
           int len,
           int isFinal);
 </pre>
 <pre class="signature">
 enum XML_Status {
   XML_STATUS_ERROR = 0,
   XML_STATUS_OK = 1
 };
 </pre>
 <div class="fcndef">
 Parse some more of the document. The string <code>s</code> is a buffer
 containing part (or perhaps all) of the document. The number of bytes of s
 that are part of the document is indicated by <code>len</code>. This means
 that <code>s</code> doesn't have to be null terminated. It also means that
 if <code>len</code> is larger than the number of bytes in the block of
 memory that <code>s</code> points at, then a memory fault is likely. The
 <code>isFinal</code> parameter informs the parser that this is the last
 piece of the document. Frequently, the last piece is empty (i.e.
 <code>len</code> is zero.)
 If a parse error occurred, it returns <code>XML_STATUS_ERROR</code>.
 Otherwise it returns <code>XML_STATUS_OK</code> value.
 </div>
 
 <pre class="fcndec" id="XML_ParseBuffer">
 enum XML_Status XMLCALL
 XML_ParseBuffer(XML_Parser p,
                 int len,
                 int isFinal);
 </pre>
 <div class="fcndef">
 This is just like <code><a href= "#XML_Parse" >XML_Parse</a></code>,
 except in this case Expat provides the buffer.  By obtaining the
 buffer from Expat with the <code><a href= "#XML_GetBuffer"
 >XML_GetBuffer</a></code> function, the application can avoid double
 copying of the input.
 </div>
 
 <pre class="fcndec" id="XML_GetBuffer">
 void * XMLCALL
 XML_GetBuffer(XML_Parser p,
               int len);
 </pre>
 <div class="fcndef">
 Obtain a buffer of size <code>len</code> to read a piece of the document
 into. A NULL value is returned if Expat can't allocate enough memory for
 this buffer. This has to be called prior to every call to
 <code><a href= "#XML_ParseBuffer" >XML_ParseBuffer</a></code>. A
 typical use would look like this:
 
 <pre class="eg">
 for (;;) {
   int bytes_read;
   void *buff = XML_GetBuffer(p, BUFF_SIZE);
   if (buff == NULL) {
     /* handle error */
   }
 
   bytes_read = read(docfd, buff, BUFF_SIZE);
   if (bytes_read &lt; 0) {
     /* handle error */
   }
 
   if (! XML_ParseBuffer(p, bytes_read, bytes_read == 0)) {
     /* handle parse error */
   }
 
   if (bytes_read == 0)
     break;
 }
 </pre>
 </div>
 
 <pre class="fcndec" id="XML_StopParser">
 enum XML_Status XMLCALL
 XML_StopParser(XML_Parser p,
                XML_Bool resumable);
 </pre>
 <div class="fcndef">
 
 <p>Stops parsing, causing <code><a href= "#XML_Parse"
 >XML_Parse</a></code> or <code><a href= "#XML_ParseBuffer"
 >XML_ParseBuffer</a></code> to return.  Must be called from within a
 call-back handler, except when aborting (when <code>resumable</code>
 is <code>XML_FALSE</code>) an already suspended parser.  Some
 call-backs may still follow because they would otherwise get
 lost, including
 <ul>
   <li> the end element handler for empty elements when stopped in the
        start element handler,</li>
   <li> the end namespace declaration handler when stopped in the end
        element handler,</li>
   <li> the character data handler when stopped in the character data handler
        while making multiple call-backs on a contiguous chunk of characters,</li>
 </ul>
 and possibly others.</p>
 
 <p>This can be called from most handlers, including DTD related
 call-backs, except when parsing an external parameter entity and
 <code>resumable</code> is <code>XML_TRUE</code>.  Returns
 <code>XML_STATUS_OK</code> when successful,
 <code>XML_STATUS_ERROR</code> otherwise.  The possible error codes
 are:</p>
 <dl>
   <dt><code>XML_ERROR_SUSPENDED</code></dt>
   <dd>when suspending an already suspended parser.</dd>
   <dt><code>XML_ERROR_FINISHED</code></dt>
   <dd>when the parser has already finished.</dd>
   <dt><code>XML_ERROR_SUSPEND_PE</code></dt>
   <dd>when suspending while parsing an external PE.</dd>
 </dl>
 
 <p>Since the stop/resume feature requires application support in the
 outer parsing loop, it is an error to call this function for a parser
 not being handled appropriately; see <a href= "#stop-resume"
 >Temporarily Stopping Parsing</a> for more information.</p>
 
 <p>When <code>resumable</code> is <code>XML_TRUE</code> then parsing
 is <em>suspended</em>, that is, <code><a href= "#XML_Parse"
 >XML_Parse</a></code> and <code><a href= "#XML_ParseBuffer"
 >XML_ParseBuffer</a></code> return <code>XML_STATUS_SUSPENDED</code>.
 Otherwise, parsing is <em>aborted</em>, that is, <code><a href=
 "#XML_Parse" >XML_Parse</a></code> and <code><a href=
 "#XML_ParseBuffer" >XML_ParseBuffer</a></code> return
 <code>XML_STATUS_ERROR</code> with error code
 <code>XML_ERROR_ABORTED</code>.</p>
 
 <p><strong>Note:</strong>
 This will be applied to the current parser instance only, that is, if
 there is a parent parser then it will continue parsing when the
 external entity reference handler returns.  It is up to the
 implementation of that handler to call <code><a href=
 "#XML_StopParser" >XML_StopParser</a></code> on the parent parser
 (recursively), if one wants to stop parsing altogether.</p>
 
 <p>When suspended, parsing can be resumed by calling <code><a href=
 "#XML_ResumeParser" >XML_ResumeParser</a></code>.</p>
 
 <p>New in Expat 1.95.8.</p>
 </div>
 
 <pre class="fcndec" id="XML_ResumeParser">
 enum XML_Status XMLCALL
 XML_ResumeParser(XML_Parser p);
 </pre>
 <div class="fcndef">
 <p>Resumes parsing after it has been suspended with <code><a href=
 "#XML_StopParser" >XML_StopParser</a></code>.  Must not be called from
 within a handler call-back.  Returns same status codes as <code><a
 href= "#XML_Parse">XML_Parse</a></code> or <code><a href=
 "#XML_ParseBuffer" >XML_ParseBuffer</a></code>.  An additional error
 code, <code>XML_ERROR_NOT_SUSPENDED</code>, will be returned if the
 parser was not currently suspended.</p>
 
 <p><strong>Note:</strong>
 This must be called on the most deeply nested child parser instance
 first, and on its parent parser only after the child parser has
 finished, to be applied recursively until the document entity's parser
 is restarted.  That is, the parent parser will not resume by itself
 and it is up to the application to call <code><a href=
 "#XML_ResumeParser" >XML_ResumeParser</a></code> on it at the
 appropriate moment.</p>
 
 <p>New in Expat 1.95.8.</p>
 </div>
 
 <pre class="fcndec" id="XML_GetParsingStatus">
 void XMLCALL
 XML_GetParsingStatus(XML_Parser p,
                      XML_ParsingStatus *status);
 </pre>
 <pre class="signature">
 enum XML_Parsing {
   XML_INITIALIZED,
   XML_PARSING,
   XML_FINISHED,
   XML_SUSPENDED
 };
 
 typedef struct {
   enum XML_Parsing parsing;
   XML_Bool finalBuffer;
 } XML_ParsingStatus;
 </pre>
 <div class="fcndef">
 <p>Returns status of parser with respect to being initialized,
 parsing, finished, or suspended, and whether the final buffer is being
 processed.  The <code>status</code> parameter <em>must not</em> be
 NULL.</p>
 
 <p>New in Expat 1.95.8.</p>
 </div>
 
 
 <h3><a name="setting">Handler Setting</a></h3>
 
 <p>Although handlers are typically set prior to parsing and left alone, an
 application may choose to set or change the handler for a parsing event
 while the parse is in progress. For instance, your application may choose
 to ignore all text not descended from a <code>para</code> element. One
 way it could do this is to set the character handler when a para start tag
 is seen, and unset it for the corresponding end tag.</p>
 
 <p>A handler may be <em>unset</em> by providing a NULL pointer to the
 appropriate handler setter. None of the handler setting functions have
 a return value.</p>
 
 <p>Your handlers will be receiving strings in arrays of type
 <code>XML_Char</code>. This type is conditionally defined in expat.h as
 either <code>char</code>, <code>wchar_t</code> or <code>unsigned short</code>.
 The former implies UTF-8 encoding, the latter two imply UTF-16 encoding.
 Note that you'll receive them in this form independent of the original
 encoding of the document.</p>
 
 <div class="handler">
 <pre class="setter" id="XML_SetStartElementHandler">
 void XMLCALL
 XML_SetStartElementHandler(XML_Parser p,
                            XML_StartElementHandler start);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_StartElementHandler)(void *userData,
                                    const XML_Char *name,
                                    const XML_Char **atts);
 </pre>
 <p>Set handler for start (and empty) tags. Attributes are passed to the start
 handler as a pointer to a vector of char pointers. Each attribute seen in
 a start (or empty) tag occupies 2 consecutive places in this vector: the
 attribute name followed by the attribute value. These pairs are terminated
 by a null pointer.</p>
 <p>Note that an empty tag generates a call to both start and end handlers
 (in that order).</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetEndElementHandler">
 void XMLCALL
 XML_SetEndElementHandler(XML_Parser p,
                          XML_EndElementHandler);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_EndElementHandler)(void *userData,
                                  const XML_Char *name);
 </pre>
 <p>Set handler for end (and empty) tags. As noted above, an empty tag
 generates a call to both start and end handlers.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetElementHandler">
 void XMLCALL
 XML_SetElementHandler(XML_Parser p,
                       XML_StartElementHandler start,
                       XML_EndElementHandler end);
 </pre>
 <p>Set handlers for start and end tags with one call.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetCharacterDataHandler">
 void XMLCALL
 XML_SetCharacterDataHandler(XML_Parser p,
                             XML_CharacterDataHandler charhndl)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_CharacterDataHandler)(void *userData,
                                     const XML_Char *s,
                                     int len);
 </pre>
 <p>Set a text handler. The string your handler receives
 is <em>NOT nul-terminated</em>. You have to use the length argument
 to deal with the end of the string. A single block of contiguous text
 free of markup may still result in a sequence of calls to this handler.
 In other words, if you're searching for a pattern in the text, it may
 be split across calls to this handler. Note: Setting this handler to NULL
 may <em>NOT immediately</em> terminate call-backs if the parser is currently
 processing such a single block of contiguous markup-free text, as the parser
 will continue calling back until the end of the block is reached.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetProcessingInstructionHandler">
 void XMLCALL
 XML_SetProcessingInstructionHandler(XML_Parser p,
                                     XML_ProcessingInstructionHandler proc)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
                                             const XML_Char *target,
                                             const XML_Char *data);
 
 </pre>
 <p>Set a handler for processing instructions. The target is the first word
 in the processing instruction. The data is the rest of the characters in
 it after skipping all whitespace after the initial word.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetCommentHandler">
 void XMLCALL
 XML_SetCommentHandler(XML_Parser p,
                       XML_CommentHandler cmnt)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_CommentHandler)(void *userData,
                               const XML_Char *data);
 </pre>
 <p>Set a handler for comments. The data is all text inside the comment
 delimiters.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetStartCdataSectionHandler">
 void XMLCALL
 XML_SetStartCdataSectionHandler(XML_Parser p,
                                 XML_StartCdataSectionHandler start);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_StartCdataSectionHandler)(void *userData);
 </pre>
 <p>Set a handler that gets called at the beginning of a CDATA section.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetEndCdataSectionHandler">
 void XMLCALL
 XML_SetEndCdataSectionHandler(XML_Parser p,
                               XML_EndCdataSectionHandler end);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_EndCdataSectionHandler)(void *userData);
 </pre>
 <p>Set a handler that gets called at the end of a CDATA section.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetCdataSectionHandler">
 void XMLCALL
 XML_SetCdataSectionHandler(XML_Parser p,
                            XML_StartCdataSectionHandler start,
                            XML_EndCdataSectionHandler end)
 </pre>
 <p>Sets both CDATA section handlers with one call.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetDefaultHandler">
 void XMLCALL
 XML_SetDefaultHandler(XML_Parser p,
                       XML_DefaultHandler hndl)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_DefaultHandler)(void *userData,
                               const XML_Char *s,
                               int len);
 </pre>
 
 <p>Sets a handler for any characters in the document which wouldn't
 otherwise be handled. This includes both data for which no handlers
 can be set (like some kinds of DTD declarations) and data which could
 be reported but which currently has no handler set.  The characters
 are passed exactly as they were present in the XML document except
 that they will be encoded in UTF-8 or UTF-16. Line boundaries are not
 normalized. Note that a byte order mark character is not passed to the
 default handler. There are no guarantees about how characters are
 divided between calls to the default handler: for example, a comment
 might be split between multiple calls.  Setting the handler with
 this call has the side effect of turning off expansion of references
 to internally defined general entities. Instead these references are
 passed to the default handler.</p>
 
 <p>See also <code><a
 href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetDefaultHandlerExpand">
 void XMLCALL
 XML_SetDefaultHandlerExpand(XML_Parser p,
                             XML_DefaultHandler hndl)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_DefaultHandler)(void *userData,
                               const XML_Char *s,
                               int len);
 </pre>
 <p>This sets a default handler, but doesn't inhibit the expansion of
 internal entity references.  The entity reference will not be passed
 to the default handler.</p>
 
 <p>See also <code><a
 href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetExternalEntityRefHandler">
 void XMLCALL
 XML_SetExternalEntityRefHandler(XML_Parser p,
                                 XML_ExternalEntityRefHandler hndl)
 </pre>
 <pre class="signature">
 typedef int
 (XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser p,
                                         const XML_Char *context,
                                         const XML_Char *base,
                                         const XML_Char *systemId,
                                         const XML_Char *publicId);
 </pre>
 <p>Set an external entity reference handler. This handler is also
 called for processing an external DTD subset if parameter entity parsing
 is in effect. (See <a href="#XML_SetParamEntityParsing">
 <code>XML_SetParamEntityParsing</code></a>.)</p>
 
 <p>The <code>context</code> parameter specifies the parsing context in
 the format expected by the <code>context</code> argument to <code><a
 href="#XML_ExternalEntityParserCreate"
 >XML_ExternalEntityParserCreate</a></code>.  <code>code</code> is
 valid only until the handler returns, so if the referenced entity is
 to be parsed later, it must be copied.  <code>context</code> is NULL
 only when the entity is a parameter entity, which is how one can
 differentiate between general and parameter entities.</p>
 
 <p>The <code>base</code> parameter is the base to use for relative
 system identifiers.  It is set by <code><a
 href="#XML_SetBase">XML_SetBase</a></code> and may be NULL. The
 <code>publicId</code> parameter is the public id given in the entity
 declaration and may be NULL.  <code>systemId</code> is the system
 identifier specified in the entity declaration and is never NULL.</p>
 
 <p>There are a couple of ways in which this handler differs from
 others.  First, this handler returns a status indicator (an
 integer). <code>XML_STATUS_OK</code> should be returned for successful
 handling of the external entity reference.  Returning
 <code>XML_STATUS_ERROR</code> indicates failure, and causes the
 calling parser to return an
 <code>XML_ERROR_EXTERNAL_ENTITY_HANDLING</code> error.</p>
 
 <p>Second, instead of having the user data as its first argument, it
 receives the parser that encountered the entity reference. This, along
 with the context parameter, may be used as arguments to a call to
 <code><a href= "#XML_ExternalEntityParserCreate"
 >XML_ExternalEntityParserCreate</a></code>.  Using the returned
 parser, the body of the external entity can be recursively parsed.</p>
 
 <p>Since this handler may be called recursively, it should not be saving
 information into global or static variables.</p>
 </div>
 
 <pre class="fcndec" id="XML_SetExternalEntityRefHandlerArg">
 void XMLCALL
 XML_SetExternalEntityRefHandlerArg(XML_Parser p,
                                    void *arg)
 </pre>
 <div class="fcndef">
 <p>Set the argument passed to the ExternalEntityRefHandler.  If
 <code>arg</code> is not NULL, it is the new value passed to the
 handler set using <code><a href="#XML_SetExternalEntityRefHandler"
 >XML_SetExternalEntityRefHandler</a></code>; if <code>arg</code> is
 NULL, the argument passed to the handler function will be the parser
 object itself.</p>
 
 <p><strong>Note:</strong>
 The type of <code>arg</code> and the type of the first argument to the
 ExternalEntityRefHandler do not match.  This function takes a
 <code>void *</code> to be passed to the handler, while the handler
 accepts an <code>XML_Parser</code>.  This is a historical accident,
 but will not be corrected before Expat 2.0 (at the earliest) to avoid
 causing compiler warnings for code that's known to work with this
 API.  It is the responsibility of the application code to know the
 actual type of the argument passed to the handler and to manage it
 properly.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetSkippedEntityHandler">
 void XMLCALL
 XML_SetSkippedEntityHandler(XML_Parser p,
                             XML_SkippedEntityHandler handler)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_SkippedEntityHandler)(void *userData,
                                     const XML_Char *entityName,
                                     int is_parameter_entity);
 </pre>
 <p>Set a skipped entity handler. This is called in two situations:</p>
 <ol>
    <li>An entity reference is encountered for which no declaration
        has been read <em>and</em> this is not an error.</li>
    <li>An internal entity reference is read, but not expanded, because
        <a href="#XML_SetDefaultHandler"><code>XML_SetDefaultHandler</code></a>
 	   has been called.</li>
 </ol>
 <p>The <code>is_parameter_entity</code> argument will be non-zero for
 a parameter entity and zero for a general entity.</p> <p>Note: skipped
 parameter entities in declarations and skipped general entities in
 attribute values cannot be reported, because the event would be out of
 sync with the reporting of the declarations or attribute values</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetUnknownEncodingHandler">
 void XMLCALL
 XML_SetUnknownEncodingHandler(XML_Parser p,
                               XML_UnknownEncodingHandler enchandler,
 			      void *encodingHandlerData)
 </pre>
 <pre class="signature">
 typedef int
 (XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
                                       const XML_Char *name,
                                       XML_Encoding *info);
 
 typedef struct {
   int map[256];
   void *data;
   int (XMLCALL *convert)(void *data, const char *s);
   void (XMLCALL *release)(void *data);
 } XML_Encoding;
 </pre>
 <p>Set a handler to deal with encodings other than the <a
 href="#builtin_encodings">built in set</a>. This should be done before
 <code><a href= "#XML_Parse" >XML_Parse</a></code> or <code><a href=
 "#XML_ParseBuffer" >XML_ParseBuffer</a></code> have been called on the
 given parser.</p> <p>If the handler knows how to deal with an encoding
 with the given name, it should fill in the <code>info</code> data
 structure and return <code>XML_STATUS_OK</code>. Otherwise it
 should return <code>XML_STATUS_ERROR</code>. The handler will be called
 at most once per parsed (external) entity. The optional application
 data pointer <code>encodingHandlerData</code> will be passed back to
 the handler.</p>
 
 <p>The map array contains information for every possible leading
 byte in a byte sequence. If the corresponding value is &gt;= 0, then it's
 a single byte sequence and the byte encodes that Unicode value. If the
 value is -1, then that byte is invalid as the initial byte in a sequence.
 If the value is -n, where n is an integer &gt; 1, then n is the number of
 bytes in the sequence and the actual conversion is accomplished by a
 call to the function pointed at by convert. This function may return -1
 if the sequence itself is invalid. The convert pointer may be null if
 there are only single byte codes. The data parameter passed to the convert
 function is the data pointer from <code>XML_Encoding</code>. The
 string s is <em>NOT</em> nul-terminated and points at the sequence of
 bytes to be converted.</p>
 
 <p>The function pointed at by <code>release</code> is called by the
 parser when it is finished with the encoding. It may be NULL.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetStartNamespaceDeclHandler">
 void XMLCALL
 XML_SetStartNamespaceDeclHandler(XML_Parser p,
 			         XML_StartNamespaceDeclHandler start);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
                                          const XML_Char *prefix,
                                          const XML_Char *uri);
 </pre>
 <p>Set a handler to be called when a namespace is declared. Namespace
 declarations occur inside start tags. But the namespace declaration start
 handler is called before the start tag handler for each namespace declared
 in that start tag.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetEndNamespaceDeclHandler">
 void XMLCALL
 XML_SetEndNamespaceDeclHandler(XML_Parser p,
 			       XML_EndNamespaceDeclHandler end);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
                                        const XML_Char *prefix);
 </pre>
 <p>Set a handler to be called when leaving the scope of a namespace
 declaration. This will be called, for each namespace declaration,
 after the handler for the end tag of the element in which the
 namespace was declared.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetNamespaceDeclHandler">
 void XMLCALL
 XML_SetNamespaceDeclHandler(XML_Parser p,
                             XML_StartNamespaceDeclHandler start,
                             XML_EndNamespaceDeclHandler end)
 </pre>
 <p>Sets both namespace declaration handlers with a single call.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetXmlDeclHandler">
 void XMLCALL
 XML_SetXmlDeclHandler(XML_Parser p,
 		      XML_XmlDeclHandler xmldecl);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_XmlDeclHandler)(void            *userData,
                               const XML_Char  *version,
                               const XML_Char  *encoding,
                               int             standalone);
 </pre>
 <p>Sets a handler that is called for XML declarations and also for
 text declarations discovered in external entities. The way to
 distinguish is that the <code>version</code> parameter will be NULL
 for text declarations. The <code>encoding</code> parameter may be NULL
 for an XML declaration. The <code>standalone</code> argument will
 contain -1, 0, or 1 indicating respectively that there was no
 standalone parameter in the declaration, that it was given as no, or
 that it was given as yes.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetStartDoctypeDeclHandler">
 void XMLCALL
 XML_SetStartDoctypeDeclHandler(XML_Parser p,
 			       XML_StartDoctypeDeclHandler start);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_StartDoctypeDeclHandler)(void           *userData,
                                        const XML_Char *doctypeName,
                                        const XML_Char *sysid,
                                        const XML_Char *pubid,
                                        int            has_internal_subset);
 </pre>
 <p>Set a handler that is called at the start of a DOCTYPE declaration,
 before any external or internal subset is parsed. Both <code>sysid</code>
 and <code>pubid</code> may be NULL. The <code>has_internal_subset</code>
 will be non-zero if the DOCTYPE declaration has an internal subset.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetEndDoctypeDeclHandler">
 void XMLCALL
 XML_SetEndDoctypeDeclHandler(XML_Parser p,
 			     XML_EndDoctypeDeclHandler end);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
 </pre>
 <p>Set a handler that is called at the end of a DOCTYPE declaration,
 after parsing any external subset.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetDoctypeDeclHandler">
 void XMLCALL
 XML_SetDoctypeDeclHandler(XML_Parser p,
 			  XML_StartDoctypeDeclHandler start,
 			  XML_EndDoctypeDeclHandler end);
 </pre>
 <p>Set both doctype handlers with one call.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetElementDeclHandler">
 void XMLCALL
 XML_SetElementDeclHandler(XML_Parser p,
 			  XML_ElementDeclHandler eldecl);
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_ElementDeclHandler)(void *userData,
                                   const XML_Char *name,
                                   XML_Content *model);
 </pre>
 <pre class="signature">
 enum XML_Content_Type {
   XML_CTYPE_EMPTY = 1,
   XML_CTYPE_ANY,
   XML_CTYPE_MIXED,
   XML_CTYPE_NAME,
   XML_CTYPE_CHOICE,
   XML_CTYPE_SEQ
 };
 
 enum XML_Content_Quant {
   XML_CQUANT_NONE,
   XML_CQUANT_OPT,
   XML_CQUANT_REP,
   XML_CQUANT_PLUS
 };
 
 typedef struct XML_cp XML_Content;
 
 struct XML_cp {
   enum XML_Content_Type		type;
   enum XML_Content_Quant	quant;
   const XML_Char *		name;
   unsigned int			numchildren;
   XML_Content *			children;
 };
 </pre>
 <p>Sets a handler for element declarations in a DTD. The handler gets
 called with the name of the element in the declaration and a pointer
 to a structure that contains the element model. It is the
 application's responsibility to free this data structure using
 <code><a href="#XML_FreeContentModel"
 >XML_FreeContentModel</a></code>.</p>
 
 <p>The <code>model</code> argument is the root of a tree of
 <code>XML_Content</code> nodes. If <code>type</code> equals
 <code>XML_CTYPE_EMPTY</code> or <code>XML_CTYPE_ANY</code>, then
 <code>quant</code> will be <code>XML_CQUANT_NONE</code>, and the other
 fields will be zero or NULL.  If <code>type</code> is
 <code>XML_CTYPE_MIXED</code>, then <code>quant</code> will be
 <code>XML_CQUANT_NONE</code> or <code>XML_CQUANT_REP</code> and
 <code>numchildren</code> will contain the number of elements that are
 allowed to be mixed in and <code>children</code> points to an array of
 <code>XML_Content</code> structures that will all have type
 XML_CTYPE_NAME with no quantification.  Only the root node can be type
 <code>XML_CTYPE_EMPTY</code>, <code>XML_CTYPE_ANY</code>, or
 <code>XML_CTYPE_MIXED</code>.</p>
 
 <p>For type <code>XML_CTYPE_NAME</code>, the <code>name</code> field
 points to the name and the <code>numchildren</code> and
 <code>children</code> fields will be zero and NULL. The
 <code>quant</code> field will indicate any quantifiers placed on the
 name.</p>
 
 <p>Types <code>XML_CTYPE_CHOICE</code> and <code>XML_CTYPE_SEQ</code>
 indicate a choice or sequence respectively. The
 <code>numchildren</code> field indicates how many nodes in the choice
 or sequence and <code>children</code> points to the nodes.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetAttlistDeclHandler">
 void XMLCALL
 XML_SetAttlistDeclHandler(XML_Parser p,
                           XML_AttlistDeclHandler attdecl);
 </pre>
 <pre class="signature">
 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);
 </pre>
 <p>Set a handler for attlist declarations in the DTD. This handler is
 called for <em>each</em> attribute. So a single attlist declaration
 with multiple attributes declared will generate multiple calls to this
 handler. The <code>elname</code> parameter returns the name of the
 element for which the attribute is being declared. The attribute name
 is in the <code>attname</code> parameter. The attribute type is in the
 <code>att_type</code> parameter.  It is the string representing the
 type in the declaration with whitespace removed.</p>
 
 <p>The <code>dflt</code> parameter holds the default value. It will be
 NULL in the case of "#IMPLIED" or "#REQUIRED" attributes. You can
 distinguish these two cases by checking the <code>isrequired</code>
 parameter, which will be true in the case of "#REQUIRED" attributes.
 Attributes which are "#FIXED" will have also have a true
 <code>isrequired</code>, but they will have the non-NULL fixed value
 in the <code>dflt</code> parameter.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetEntityDeclHandler">
 void XMLCALL
 XML_SetEntityDeclHandler(XML_Parser p,
 			 XML_EntityDeclHandler handler);
 </pre>
 <pre class="signature">
 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);
 </pre>
 <p>Sets a handler that will be called for all entity declarations.
 The <code>is_parameter_entity</code> argument will be non-zero in the
 case of parameter entities and zero otherwise.</p>
 
 <p>For internal entities (<code>&lt;!ENTITY foo "bar"&gt;</code>),
 <code>value</code> will be non-NULL and <code>systemId</code>,
 <code>publicId</code>, and <code>notationName</code> will all be NULL.
 The value string is <em>not</em> NULL terminated; the length is
 provided in the <code>value_length</code> parameter. Do not use
 <code>value_length</code> to test for internal entities, since it is
 legal to have zero-length values. Instead check for whether or not
 <code>value</code> is NULL.</p> <p>The <code>notationName</code>
 argument will have a non-NULL value only for unparsed entity
 declarations.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetUnparsedEntityDeclHandler">
 void XMLCALL
 XML_SetUnparsedEntityDeclHandler(XML_Parser p,
                                  XML_UnparsedEntityDeclHandler h)
 </pre>
 <pre class="signature">
 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);
 </pre>
 <p>Set a handler that receives declarations of unparsed entities. These
 are entity declarations that have a notation (NDATA) field:</p>
 
 <div id="eg"><pre>
 &lt;!ENTITY logo SYSTEM "images/logo.gif" NDATA gif&gt;
 </pre></div>
 <p>This handler is obsolete and is provided for backwards
 compatibility.  Use instead <a href= "#XML_SetEntityDeclHandler"
 >XML_SetEntityDeclHandler</a>.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetNotationDeclHandler">
 void XMLCALL
 XML_SetNotationDeclHandler(XML_Parser p,
                            XML_NotationDeclHandler h)
 </pre>
 <pre class="signature">
 typedef void
 (XMLCALL *XML_NotationDeclHandler)(void *userData, 
                                    const XML_Char *notationName,
                                    const XML_Char *base,
                                    const XML_Char *systemId,
                                    const XML_Char *publicId);
 </pre>
 <p>Set a handler that receives notation declarations.</p>
 </div>
 
 <div class="handler">
 <pre class="setter" id="XML_SetNotStandaloneHandler">
 void XMLCALL
 XML_SetNotStandaloneHandler(XML_Parser p,
                             XML_NotStandaloneHandler h)
 </pre>
 <pre class="signature">
 typedef int 
 (XMLCALL *XML_NotStandaloneHandler)(void *userData);
 </pre>
 <p>Set a handler that is called if the document is not "standalone".
 This happens when there is an external subset or a reference to a
 parameter entity, but does not have standalone set to "yes" in an XML
 declaration.  If this handler returns <code>XML_STATUS_ERROR</code>,
 then the parser will throw an <code>XML_ERROR_NOT_STANDALONE</code>
 error.</p>
 </div>
 
 <h3><a name="position">Parse position and error reporting functions</a></h3>
 
 <p>These are the functions you'll want to call when the parse
 functions return <code>XML_STATUS_ERROR</code> (a parse error has
 occurred), although the position reporting functions are useful outside
 of errors. The position reported is the byte position (in the original
 document or entity encoding) of the first of the sequence of
 characters that generated the current event (or the error that caused
 the parse functions to return <code>XML_STATUS_ERROR</code>.)  The
 exceptions are callbacks trigged by declarations in the document
 prologue, in which case they exact position reported is somewhere in the
 relevant markup, but not necessarily as meaningful as for other
 events.</p>
 
 <p>The position reporting functions are accurate only outside of the
 DTD.  In other words, they usually return bogus information when
 called from within a DTD declaration handler.</p>
 
 <pre class="fcndec" id="XML_GetErrorCode">
 enum XML_Error XMLCALL
 XML_GetErrorCode(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return what type of error has occurred.
 </div>
 
 <pre class="fcndec" id="XML_ErrorString">
 const XML_LChar * XMLCALL
 XML_ErrorString(enum XML_Error code);
 </pre>
 <div class="fcndef">
 Return a string describing the error corresponding to code.
 The code should be one of the enums that can be returned from
 <code><a href= "#XML_GetErrorCode" >XML_GetErrorCode</a></code>.
 </div>
 
 <pre class="fcndec" id="XML_GetCurrentByteIndex">
 XML_Index XMLCALL
 XML_GetCurrentByteIndex(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return the byte offset of the position.  This always corresponds to
 the values returned by <code><a href= "#XML_GetCurrentLineNumber"
 >XML_GetCurrentLineNumber</a></code> and <code><a href=
 "#XML_GetCurrentColumnNumber" >XML_GetCurrentColumnNumber</a></code>.
 </div>
 
 <pre class="fcndec" id="XML_GetCurrentLineNumber">
 XML_Size XMLCALL
 XML_GetCurrentLineNumber(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return the line number of the position.  The first line is reported as
 <code>1</code>.
 </div>
 
 <pre class="fcndec" id="XML_GetCurrentColumnNumber">
 XML_Size XMLCALL
 XML_GetCurrentColumnNumber(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return the offset, from the beginning of the current line, of
 the position.
 </div>
 
 <pre class="fcndec" id="XML_GetCurrentByteCount">
 int XMLCALL
 XML_GetCurrentByteCount(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return the number of bytes in the current event. Returns
 <code>0</code> if the event is inside a reference to an internal
 entity and for the end-tag event for empty element tags (the later can
 be used to distinguish empty-element tags from empty elements using
 separate start and end tags).
 </div>
 
 <pre class="fcndec" id="XML_GetInputContext">
 const char * XMLCALL
 XML_GetInputContext(XML_Parser p,
                     int *offset,
                     int *size);
 </pre>
 <div class="fcndef">
 
 <p>Returns the parser's input buffer, sets the integer pointed at by
 <code>offset</code> to the offset within this buffer of the current
 parse position, and set the integer pointed at by <code>size</code> to
 the size of the returned buffer.</p>
 
 <p>This should only be called from within a handler during an active
 parse and the returned buffer should only be referred to from within
 the handler that made the call. This input buffer contains the
 untranslated bytes of the input.</p>
 
 <p>Only a limited amount of context is kept, so if the event
 triggering a call spans over a very large amount of input, the actual
 parse position may be before the beginning of the buffer.</p>
 
 <p>If <code>XML_CONTEXT_BYTES</code> is not defined, this will always
 return NULL.</p>
 </div>
 
 <h3><a name="miscellaneous">Miscellaneous functions</a></h3>
 
 <p>The functions in this section either obtain state information from
 the parser or can be used to dynamically set parser options.</p>
 
 <pre class="fcndec" id="XML_SetUserData">
 void XMLCALL
 XML_SetUserData(XML_Parser p,
                 void *userData);
 </pre>
 <div class="fcndef">
 This sets the user data pointer that gets passed to handlers.  It
 overwrites any previous value for this pointer. Note that the
 application is responsible for freeing the memory associated with
 <code>userData</code> when it is finished with the parser. So if you
 call this when there's already a pointer there, and you haven't freed
 the memory associated with it, then you've probably just leaked
 memory.
 </div>
 
 <pre class="fcndec" id="XML_GetUserData">
 void * XMLCALL
 XML_GetUserData(XML_Parser p);
 </pre>
 <div class="fcndef">
 This returns the user data pointer that gets passed to handlers.
 It is actually implemented as a macro.
 </div>
 
 <pre class="fcndec" id="XML_UseParserAsHandlerArg">
 void XMLCALL
 XML_UseParserAsHandlerArg(XML_Parser p);
 </pre>
 <div class="fcndef">
 After this is called, handlers receive the parser in their
 <code>userData</code> arguments.  The user data can still be obtained
 using the <code><a href= "#XML_GetUserData"
 >XML_GetUserData</a></code> function.
 </div>
 
 <pre class="fcndec" id="XML_SetBase">
 enum XML_Status XMLCALL
 XML_SetBase(XML_Parser p,
             const XML_Char *base);
 </pre>
 <div class="fcndef">
 Set the base to be used for resolving relative URIs in system
 identifiers.  The return value is <code>XML_STATUS_ERROR</code> if
 there's no memory to store base, otherwise it's
 <code>XML_STATUS_OK</code>.
 </div>
 
 <pre class="fcndec" id="XML_GetBase">
 const XML_Char * XMLCALL
 XML_GetBase(XML_Parser p);
 </pre>
 <div class="fcndef">
 Return the base for resolving relative URIs.
 </div>
 
 <pre class="fcndec" id="XML_GetSpecifiedAttributeCount">
 int XMLCALL
 XML_GetSpecifiedAttributeCount(XML_Parser p);
 </pre>
 <div class="fcndef">
 When attributes are reported to the start handler in the atts vector,
 attributes that were explicitly set in the element occur before any
 attributes that receive their value from default information in an
 ATTLIST declaration. This function returns the number of attributes
 that were explicitly set times two, thus giving the offset in the
 <code>atts</code> array passed to the start tag handler of the first
 attribute set due to defaults. It supplies information for the last
 call to a start handler. If called inside a start handler, then that
 means the current call.
 </div>
 
 <pre class="fcndec" id="XML_GetIdAttributeIndex">
 int XMLCALL
 XML_GetIdAttributeIndex(XML_Parser p);
 </pre>
 <div class="fcndef">
 Returns the index of the ID attribute passed in the atts array in the
 last call to <code><a href= "#XML_StartElementHandler"
 >XML_StartElementHandler</a></code>, or -1 if there is no ID
 attribute. If called inside a start handler, then that means the
 current call.
 </div>
 
 <pre class="fcndec" id="XML_GetAttributeInfo">
 const XML_AttrInfo * XMLCALL
 XML_GetAttributeInfo(XML_Parser parser);
 </pre>
 <pre class="signature">
 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_AttrInfo;
 </pre>
 <div class="fcndef">
 Returns an array of <code>XML_AttrInfo</code> structures for the
 attribute/value pairs passed in the last call to the
 <code>XML_StartElementHandler</code> that were specified
 in the start-tag rather than defaulted. Each attribute/value pair counts
 as 1; thus the number of entries in the array is
 <code>XML_GetSpecifiedAttributeCount(parser) / 2</code>.
 </div>
 
 <pre class="fcndec" id="XML_SetEncoding">
 enum XML_Status XMLCALL
 XML_SetEncoding(XML_Parser p,
                 const XML_Char *encoding);
 </pre>
 <div class="fcndef">
 Set the encoding to be used by the parser. It is equivalent to
 passing a non-null encoding argument to the parser creation functions.
 It must not be called after <code><a href= "#XML_Parse"
 >XML_Parse</a></code> or <code><a href= "#XML_ParseBuffer"
 >XML_ParseBuffer</a></code> have been called on the given parser.
 Returns <code>XML_STATUS_OK</code> on success or
 <code>XML_STATUS_ERROR</code> on error.
 </div>
 
 <pre class="fcndec" id="XML_SetParamEntityParsing">
 int XMLCALL
 XML_SetParamEntityParsing(XML_Parser p,
                           enum XML_ParamEntityParsing code);
 </pre>
 <div class="fcndef">
 This enables parsing of parameter entities, including the external
 parameter entity that is the external DTD subset, according to
 <code>code</code>.
 The choices for <code>code</code> are:
 <ul>
 <li><code>XML_PARAM_ENTITY_PARSING_NEVER</code></li>
 <li><code>XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE</code></li>
 <li><code>XML_PARAM_ENTITY_PARSING_ALWAYS</code></li>
 </ul>
 <b>Note:</b> If <code>XML_SetParamEntityParsing</code> is called after 
 <code>XML_Parse</code> or <code>XML_ParseBuffer</code>, then it has
 no effect and will always return 0.
 </div>
 
 <pre class="fcndec" id="XML_SetHashSalt">
 int XMLCALL
 XML_SetHashSalt(XML_Parser p,
                 unsigned long hash_salt);
 </pre>
 <div class="fcndef">
 Sets the hash salt to use for internal hash calculations.
 Helps in preventing DoS attacks based on predicting hash
 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
 such a call will have no effect, even if it returns 1.</p>
 </div>
 
 <pre class="fcndec" id="XML_UseForeignDTD">
 enum XML_Error XMLCALL
 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
 </pre>
 <div class="fcndef">
 <p>This function allows an application to provide an external subset
 for the document type declaration for documents which do not specify
 an external subset of their own.  For documents which specify an
 external subset in their DOCTYPE declaration, the application-provided
 subset will be ignored.  If the document does not contain a DOCTYPE
 declaration at all and <code>useDTD</code> is true, the
 application-provided subset will be parsed, but the
 <code>startDoctypeDeclHandler</code> and
 <code>endDoctypeDeclHandler</code> functions, if set, will not be
 called.  The setting of parameter entity parsing, controlled using
 <code><a href= "#XML_SetParamEntityParsing"
 >XML_SetParamEntityParsing</a></code>, will be honored.</p>
 
 <p>The application-provided external subset is read by calling the
 external entity reference handler set via <code><a href=
 "#XML_SetExternalEntityRefHandler"
 >XML_SetExternalEntityRefHandler</a></code> with both
 <code>publicId</code> and <code>systemId</code> set to NULL.</p>
 
 <p>If this function is called after parsing has begun, it returns
 <code>XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING</code> and ignores
 <code>useDTD</code>.  If called when Expat has been compiled without
 DTD support, it returns
 <code>XML_ERROR_FEATURE_REQUIRES_XML_DTD</code>.  Otherwise, it
 returns <code>XML_ERROR_NONE</code>.</p>
 
 <p><b>Note:</b> For the purpose of checking WFC: Entity Declared, passing
 <code>useDTD == XML_TRUE</code> will make the parser behave as if
 the document had a DTD with an external subset. This holds true even if
 the external entity reference handler returns without action.</p>
 </div>
 
 <pre class="fcndec" id="XML_SetReturnNSTriplet">
 void XMLCALL
 XML_SetReturnNSTriplet(XML_Parser parser,
                        int        do_nst);
 </pre>
 <div class="fcndef">
 <p>
 This function only has an effect when using a parser created with
 <code><a href= "#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>,
 i.e. when namespace processing is in effect. The <code>do_nst</code>
 sets whether or not prefixes are returned with names qualified with a
 namespace prefix. If this function is called with <code>do_nst</code>
 non-zero, then afterwards namespace qualified names (that is qualified
 with a prefix as opposed to belonging to a default namespace) are
 returned as a triplet with the three parts separated by the namespace
 separator specified when the parser was created.  The order of
 returned parts is URI, local name, and prefix.</p> <p>If
 <code>do_nst</code> is zero, then namespaces are reported in the
 default manner, URI then local_name separated by the namespace
 separator.</p>
 </div>
 
 <pre class="fcndec" id="XML_DefaultCurrent">
 void XMLCALL
 XML_DefaultCurrent(XML_Parser parser);
 </pre>
 <div class="fcndef">
 This can be called within a handler for a start element, end element,
 processing instruction or character data.  It causes the corresponding
 markup to be passed to the default handler set by <code><a
 href="#XML_SetDefaultHandler" >XML_SetDefaultHandler</a></code> or
 <code><a href="#XML_SetDefaultHandlerExpand"
 >XML_SetDefaultHandlerExpand</a></code>.  It does nothing if there is
 not a default handler.
 </div>
 
 <pre class="fcndec" id="XML_ExpatVersion">
 XML_LChar * XMLCALL
 XML_ExpatVersion();
 </pre>
 <div class="fcndef">
 Return the library version as a string (e.g. <code>"expat_1.95.1"</code>).
 </div>
 
 <pre class="fcndec" id="XML_ExpatVersionInfo">
 struct XML_Expat_Version XMLCALL
 XML_ExpatVersionInfo();
 </pre>
 <pre class="signature">
 typedef struct {
   int major;
   int minor;
   int micro;
 } XML_Expat_Version;
 </pre>
 <div class="fcndef">
 Return the library version information as a structure.
 Some macros are also defined that support compile-time tests of the
 library version:
 <ul>
 <li><code>XML_MAJOR_VERSION</code></li>
 <li><code>XML_MINOR_VERSION</code></li>
 <li><code>XML_MICRO_VERSION</code></li>
 </ul>
 Testing these constants is currently the best way to determine if
 particular parts of the Expat API are available.
 </div>
 
 <pre class="fcndec" id="XML_GetFeatureList">
 const XML_Feature * XMLCALL
 XML_GetFeatureList();
 </pre>
 <pre class="signature">
 enum XML_FeatureEnum {
   XML_FEATURE_END = 0,
   XML_FEATURE_UNICODE,
   XML_FEATURE_UNICODE_WCHAR_T,
   XML_FEATURE_DTD,
   XML_FEATURE_CONTEXT_BYTES,
   XML_FEATURE_MIN_SIZE,
   XML_FEATURE_SIZEOF_XML_CHAR,
   XML_FEATURE_SIZEOF_XML_LCHAR,
   XML_FEATURE_NS,
   XML_FEATURE_LARGE_SIZE
 };
 
 typedef struct {
   enum XML_FeatureEnum  feature;
   XML_LChar            *name;
   long int              value;
 } XML_Feature;
 </pre>
 <div class="fcndef">
 <p>Returns a list of "feature" records, providing details on how
 Expat was configured at compile time.  Most applications should not
 need to worry about this, but this information is otherwise not
 available from Expat.  This function allows code that does need to
 check these features to do so at runtime.</p>
 
 <p>The return value is an array of <code>XML_Feature</code>,
 terminated by a record with a <code>feature</code> of
 <code>XML_FEATURE_END</code> and <code>name</code> of NULL,
 identifying the feature-test macros Expat was compiled with.  Since an
 application that requires this kind of information needs to determine
 the type of character the <code>name</code> points to, records for the
 <code>XML_FEATURE_SIZEOF_XML_CHAR</code> and
 <code>XML_FEATURE_SIZEOF_XML_LCHAR</code> will be located at the
 beginning of the list, followed by <code>XML_FEATURE_UNICODE</code>
 and <code>XML_FEATURE_UNICODE_WCHAR_T</code>, if they are present at
 all.</p>
 
 <p>Some features have an associated value.  If there isn't an
 associated value, the <code>value</code> field is set to 0.  At this
 time, the following features have been defined to have values:</p>
 
 <dl>
   <dt><code>XML_FEATURE_SIZEOF_XML_CHAR</code></dt>
   <dd>The number of bytes occupied by one <code>XML_Char</code>
   character.</dd>
   <dt><code>XML_FEATURE_SIZEOF_XML_LCHAR</code></dt>
   <dd>The number of bytes occupied by one <code>XML_LChar</code>
   character.</dd>
   <dt><code>XML_FEATURE_CONTEXT_BYTES</code></dt>
   <dd>The maximum number of characters of context which can be
   reported by <code><a href= "#XML_GetInputContext"
   >XML_GetInputContext</a></code>.</dd>
 </dl>
 </div>
 
 <pre class="fcndec" id="XML_FreeContentModel">
 void XMLCALL
 XML_FreeContentModel(XML_Parser parser, XML_Content *model);
 </pre>
 <div class="fcndef">
 Function to deallocate the <code>model</code> argument passed to the
 <code>XML_ElementDeclHandler</code> callback set using <code><a
 href="#XML_SetElementDeclHandler" >XML_ElementDeclHandler</a></code>.
 This function should not be used for any other purpose.
 </div>
 
 <p>The following functions allow external code to share the memory
 allocator an <code>XML_Parser</code> has been configured to use.  This
 is especially useful for third-party libraries that interact with a
 parser object created by application code, or heavily layered
 applications.  This can be essential when using dynamically loaded
 libraries which use different C standard libraries (this can happen on
 Windows, at least).</p>
 
 <pre class="fcndec" id="XML_MemMalloc">
 void * XMLCALL
 XML_MemMalloc(XML_Parser parser, size_t size);
 </pre>
 <div class="fcndef">
 Allocate <code>size</code> bytes of memory using the allocator the
 <code>parser</code> object has been configured to use.  Returns a
 pointer to the memory or NULL on failure.  Memory allocated in this
 way must be freed using <code><a href="#XML_MemFree"
 >XML_MemFree</a></code>.
 </div>
 
 <pre class="fcndec" id="XML_MemRealloc">
 void * XMLCALL
 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
 </pre>
 <div class="fcndef">
 Allocate <code>size</code> bytes of memory using the allocator the
 <code>parser</code> object has been configured to use.
 <code>ptr</code> must point to a block of memory allocated by <code><a
 href="#XML_MemMalloc" >XML_MemMalloc</a></code> or
 <code>XML_MemRealloc</code>, or be NULL.  This function tries to
 expand the block pointed to by <code>ptr</code> if possible.  Returns
 a pointer to the memory or NULL on failure.  On success, the original
 block has either been expanded or freed.  On failure, the original
 block has not been freed; the caller is responsible for freeing the
 original block.  Memory allocated in this way must be freed using
 <code><a href="#XML_MemFree"
 >XML_MemFree</a></code>.
 </div>
 
 <pre class="fcndec" id="XML_MemFree">
 void XMLCALL
 XML_MemFree(XML_Parser parser, void *ptr);
 </pre>
 <div class="fcndef">
 Free a block of memory pointed to by <code>ptr</code>.  The block must
 have been allocated by <code><a href="#XML_MemMalloc"
 >XML_MemMalloc</a></code> or <code>XML_MemRealloc</code>, or be NULL.
 </div>
 
 <hr />
 <p><a href="http://validator.w3.org/check/referer"><img
         src="valid-xhtml10.png" alt="Valid XHTML 1.0!"
         height="31" width="88" class="noborder" /></a></p>
 </div>
 </body>
 </html>
Index: vendor/expat/dist/examples/Makefile.in
===================================================================
--- vendor/expat/dist/examples/Makefile.in	(revision 355070)
+++ vendor/expat/dist/examples/Makefile.in	(revision 355071)
@@ -1,636 +1,655 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 noinst_PROGRAMS = elements$(EXEEXT) outline$(EXEEXT)
 subdir = examples
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 PROGRAMS = $(noinst_PROGRAMS)
 am_elements_OBJECTS = elements.$(OBJEXT)
 elements_OBJECTS = $(am_elements_OBJECTS)
 elements_DEPENDENCIES = ../lib/libexpat.la
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
 am_outline_OBJECTS = outline.$(OBJEXT)
 outline_OBJECTS = $(am_outline_OBJECTS)
 outline_DEPENDENCIES = ../lib/libexpat.la
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 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)
 LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
 am__v_CC_0 = @echo "  CC      " $@;
 am__v_CC_1 = 
 CCLD = $(CC)
 LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 SOURCES = $(elements_SOURCES) $(outline_SOURCES)
 DIST_SOURCES = $(elements_SOURCES) $(outline_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 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
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 am__DIST_COMMON = $(srcdir)/Makefile.in \
 	$(top_srcdir)/conftools/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 AM_CPPFLAGS = -I$(srcdir)/../lib
 elements_SOURCES = elements.c
 elements_LDADD = ../lib/libexpat.la
 outline_SOURCES = outline.c
 outline_LDADD = ../lib/libexpat.la
 all: all-am
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .o .obj
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu examples/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu examples/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 
 clean-noinstPROGRAMS:
 	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
 	echo " rm -f" $$list; \
 	rm -f $$list || exit $$?; \
 	test -n "$(EXEEXT)" || exit 0; \
 	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
 	echo " rm -f" $$list; \
 	rm -f $$list
 
 elements$(EXEEXT): $(elements_OBJECTS) $(elements_DEPENDENCIES) $(EXTRA_elements_DEPENDENCIES) 
 	@rm -f elements$(EXEEXT)
 	$(AM_V_CCLD)$(LINK) $(elements_OBJECTS) $(elements_LDADD) $(LIBS)
 
 outline$(EXEEXT): $(outline_OBJECTS) $(outline_DEPENDENCIES) $(EXTRA_outline_DEPENDENCIES) 
 	@rm -f outline$(EXEEXT)
 	$(AM_V_CCLD)$(LINK) $(outline_OBJECTS) $(outline_LDADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 
 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 $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
 
 .c.obj:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .c.lo:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-am
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-am
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscopelist: cscopelist-am
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 check-am: all-am
 check: check-am
 all-am: Makefile $(PROGRAMS)
 installdirs:
 install: install-am
 install-exec: install-exec-am
 install-data: install-data-am
 uninstall: uninstall-am
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-am
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-am
 
 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
 
 dvi: dvi-am
 
 dvi-am:
 
 html: html-am
 
 html-am:
 
 info: info-am
 
 info-am:
 
 install-data-am:
 
 install-dvi: install-dvi-am
 
 install-dvi-am:
 
 install-exec-am:
 
 install-html: install-html-am
 
 install-html-am:
 
 install-info: install-info-am
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-am
 
 install-pdf-am:
 
 install-ps: install-ps-am
 
 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
 
 mostlyclean: mostlyclean-am
 
 mostlyclean-am: mostlyclean-compile mostlyclean-generic \
 	mostlyclean-libtool
 
 pdf: pdf-am
 
 pdf-am:
 
 ps: ps-am
 
 ps-am:
 
 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 \
 	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 maintainer-clean \
 	maintainer-clean-generic mostlyclean mostlyclean-compile \
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	tags tags-am uninstall uninstall-am
 
 .PRECIOUS: Makefile
 
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/examples/elements.c
===================================================================
--- vendor/expat/dist/examples/elements.c	(revision 355070)
+++ vendor/expat/dist/examples/elements.c	(revision 355071)
@@ -1,104 +1,97 @@
 /* This is simple demonstration of how to use expat. This program
    reads an XML document from standard input and writes a line with
    the name of each element to standard output indenting child
    elements by one tab stop more than their parent element.
    It must be used with Expat compiled for UTF-8 output.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <stdio.h>
 #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;
 
   for (i = 0; i < *depthPtr; i++)
     putchar('\t');
   printf("%" XML_FMT_STR "\n", name);
   *depthPtr += 1;
 }
 
 static void XMLCALL
-endElement(void *userData, const XML_Char *name)
-{
+endElement(void *userData, const XML_Char *name) {
   int *depthPtr = (int *)userData;
   (void)name;
 
   *depthPtr -= 1;
 }
 
 int
-main(int argc, char *argv[])
-{
+main(int argc, char *argv[]) {
   char buf[BUFSIZ];
   XML_Parser parser = XML_ParserCreate(NULL);
   int done;
   int depth = 0;
   (void)argc;
   (void)argv;
 
   XML_SetUserData(parser, &depth);
   XML_SetElementHandler(parser, startElement, endElement);
   do {
     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;
 }
Index: vendor/expat/dist/examples/outline.c
===================================================================
--- vendor/expat/dist/examples/outline.c	(revision 355070)
+++ vendor/expat/dist/examples/outline.c	(revision 355071)
@@ -1,126 +1,119 @@
 /* Read an XML document from standard input and print an element
    outline on standard output.
    Must be used with Expat compiled for UTF-8 output.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <stdio.h>
 #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;
 
   for (i = 0; i < Depth; i++)
     printf("  ");
 
   printf("%" XML_FMT_STR, el);
 
   for (i = 0; attr[i]; i += 2) {
     printf(" %" XML_FMT_STR "='%" XML_FMT_STR "'", attr[i], attr[i + 1]);
   }
 
   printf("\n");
   Depth++;
 }
 
 static void XMLCALL
-end(void *data, const XML_Char *el)
-{
+end(void *data, const XML_Char *el) {
   (void)data;
   (void)el;
 
   Depth--;
 }
 
 int
-main(int argc, char *argv[])
-{
+main(int argc, char *argv[]) {
   XML_Parser p = XML_ParserCreate(NULL);
   (void)argc;
   (void)argv;
 
   if (! p) {
     fprintf(stderr, "Couldn't allocate memory for parser\n");
     exit(-1);
   }
 
   XML_SetElementHandler(p, start, end);
 
   for (;;) {
     int done;
     int len;
 
     len = (int)fread(Buff, 1, BUFFSIZE, stdin);
     if (ferror(stdin)) {
       fprintf(stderr, "Read error\n");
       exit(-1);
     }
     done = feof(stdin);
 
     if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) {
       fprintf(stderr,
               "Parse error at line %" XML_FMT_INT_MOD "u:\n%" XML_FMT_STR "\n",
               XML_GetCurrentLineNumber(p),
               XML_ErrorString(XML_GetErrorCode(p)));
       exit(-1);
     }
 
     if (done)
       break;
   }
   XML_ParserFree(p);
   return 0;
 }
Index: vendor/expat/dist/expat_config.h.in
===================================================================
--- vendor/expat/dist/expat_config.h.in	(revision 355070)
+++ vendor/expat/dist/expat_config.h.in	(revision 355071)
@@ -1,122 +1,132 @@
 /* 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. */
 #undef HAVE_ARC4RANDOM
 
 /* 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
 
 /* Define to 1 if you have the <fcntl.h> header file. */
 #undef HAVE_FCNTL_H
 
 /* Define to 1 if you have the `getpagesize' function. */
 #undef HAVE_GETPAGESIZE
 
 /* Define to 1 if you have the `getrandom' function. */
 #undef HAVE_GETRANDOM
 
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
 /* 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
 
 /* Define to 1 if you have a working `mmap' system call. */
 #undef HAVE_MMAP
 
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 
 /* Define to 1 if you have the <stdlib.h> header file. */
 #undef HAVE_STDLIB_H
 
 /* Define to 1 if you have the <strings.h> header file. */
 #undef HAVE_STRINGS_H
 
 /* Define to 1 if you have the <string.h> header file. */
 #undef HAVE_STRING_H
 
 /* Define to 1 if you have `syscall' and `SYS_getrandom'. */
 #undef HAVE_SYSCALL_GETRANDOM
 
 /* Define to 1 if you have the <sys/param.h> header file. */
 #undef HAVE_SYS_PARAM_H
 
 /* Define to 1 if you have the <sys/stat.h> header file. */
 #undef HAVE_SYS_STAT_H
 
 /* Define to 1 if you have the <sys/types.h> header file. */
 #undef HAVE_SYS_TYPES_H
 
 /* Define to 1 if you have the <unistd.h> header file. */
 #undef HAVE_UNISTD_H
 
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #undef LT_OBJDIR
 
 /* Name of package */
 #undef PACKAGE
 
 /* Define to the address where bug reports for this package should be sent. */
 #undef PACKAGE_BUGREPORT
 
 /* Define to the full name of this package. */
 #undef PACKAGE_NAME
 
 /* Define to the full name and version of this package. */
 #undef PACKAGE_STRING
 
 /* Define to the one symbol short name of this package. */
 #undef PACKAGE_TARNAME
 
 /* Define to the home page for this package. */
 #undef PACKAGE_URL
 
 /* Define to the version of this package. */
 #undef PACKAGE_VERSION
 
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
 
 /* 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. */
 #undef XML_CONTEXT_BYTES
 
 /* Define to include code reading entropy from `/dev/urandom'. */
 #undef XML_DEV_URANDOM
 
 /* Define to make parameter entity parsing functionality available. */
 #undef XML_DTD
 
 /* Define to make XML Namespaces functionality available. */
 #undef XML_NS
 
 /* Define to empty if `const' does not conform to ANSI C. */
 #undef const
 
 /* Define to `long int' if <sys/types.h> does not define. */
 #undef off_t
 
 /* Define to `unsigned int' if <sys/types.h> does not define. */
 #undef size_t
Index: vendor/expat/dist/fix-xmltest-log.sh
===================================================================
--- vendor/expat/dist/fix-xmltest-log.sh	(nonexistent)
+++ vendor/expat/dist/fix-xmltest-log.sh	(revision 355071)
@@ -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}"

Property changes on: vendor/expat/dist/fix-xmltest-log.sh
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/expat/dist/lib/Makefile.am
===================================================================
--- vendor/expat/dist/lib/Makefile.am	(revision 355070)
+++ vendor/expat/dist/lib/Makefile.am	(revision 355071)
@@ -1,76 +1,75 @@
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 include_HEADERS = \
     ../expat_config.h \
     expat.h \
     expat_external.h
 
 lib_LTLIBRARIES = libexpat.la
 
 libexpat_la_LDFLAGS = \
     -no-undefined \
     -version-info @LIBCURRENT@:@LIBREVISION@:@LIBAGE@
 
 libexpat_la_SOURCES = \
-    loadlibrary.c \
     xmlparse.c \
     xmltok.c \
     xmlrole.c
 
 doc_DATA = \
     ../AUTHORS \
     ../Changes
 
 install-data-hook:
 	cd "$(DESTDIR)$(docdir)" && $(am__mv) Changes changelog
 
 uninstall-local:
 	$(RM) "$(DESTDIR)$(docdir)/changelog"
 
 EXTRA_DIST = \
     ascii.h \
     asciitab.h \
     expat_external.h \
     expat.h \
     iasciitab.h \
     internal.h \
     latin1tab.h \
     libexpat.def \
     libexpatw.def \
     nametab.h \
     siphash.h \
     utf8tab.h \
     winconfig.h \
     xmlrole.h \
     xmltok.h \
     xmltok_impl.c \
     xmltok_impl.h \
     xmltok_ns.c
Index: vendor/expat/dist/lib/Makefile.in
===================================================================
--- vendor/expat/dist/lib/Makefile.in	(revision 355070)
+++ vendor/expat/dist/lib/Makefile.in	(revision 355071)
@@ -1,784 +1,803 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 subdir = lib
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(include_HEADERS) \
 	$(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     *) f=$$p;; \
   esac;
 am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
 am__install_max = 40
 am__nobase_strip_setup = \
   srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
 am__nobase_strip = \
   for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
 am__nobase_list = $(am__nobase_strip_setup); \
   for p in $$list; do echo "$$p $$p"; done | \
   sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
   $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
     if (++n[$$2] == $(am__install_max)) \
       { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
     END { for (dir in files) print dir, files[dir] }'
 am__base_list = \
   sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
   sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
 am__uninstall_files_from_dir = { \
   test -z "$$files" \
     || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
     || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
 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@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
 libexpat_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(libexpat_la_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 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)
 LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
 am__v_CC_0 = @echo "  CC      " $@;
 am__v_CC_1 = 
 CCLD = $(CC)
 LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 SOURCES = $(libexpat_la_SOURCES)
 DIST_SOURCES = $(libexpat_la_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 DATA = $(doc_DATA)
 HEADERS = $(include_HEADERS)
 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
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 am__DIST_COMMON = $(srcdir)/Makefile.in \
 	$(top_srcdir)/conftools/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 include_HEADERS = \
     ../expat_config.h \
     expat.h \
     expat_external.h
 
 lib_LTLIBRARIES = libexpat.la
 libexpat_la_LDFLAGS = \
     -no-undefined \
     -version-info @LIBCURRENT@:@LIBREVISION@:@LIBAGE@
 
 libexpat_la_SOURCES = \
-    loadlibrary.c \
     xmlparse.c \
     xmltok.c \
     xmlrole.c
 
 doc_DATA = \
     ../AUTHORS \
     ../Changes
 
 EXTRA_DIST = \
     ascii.h \
     asciitab.h \
     expat_external.h \
     expat.h \
     iasciitab.h \
     internal.h \
     latin1tab.h \
     libexpat.def \
     libexpatw.def \
     nametab.h \
     siphash.h \
     utf8tab.h \
     winconfig.h \
     xmlrole.h \
     xmltok.h \
     xmltok_impl.c \
     xmltok_impl.h \
     xmltok_ns.c
 
 all: all-am
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .o .obj
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu lib/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu lib/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 
 install-libLTLIBRARIES: $(lib_LTLIBRARIES)
 	@$(NORMAL_INSTALL)
 	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
 	list2=; for p in $$list; do \
 	  if test -f $$p; then \
 	    list2="$$list2 $$p"; \
 	  else :; fi; \
 	done; \
 	test -z "$$list2" || { \
 	  echo " $(MKDIR_P) '$(DESTDIR)$(libdir)'"; \
 	  $(MKDIR_P) "$(DESTDIR)$(libdir)" || exit 1; \
 	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
 	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
 	}
 
 uninstall-libLTLIBRARIES:
 	@$(NORMAL_UNINSTALL)
 	@list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
 	for p in $$list; do \
 	  $(am__strip_dir) \
 	  echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
 	  $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
 	done
 
 clean-libLTLIBRARIES:
 	-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
 	@list='$(lib_LTLIBRARIES)'; \
 	locs=`for p in $$list; do echo $$p; done | \
 	      sed 's|^[^/]*$$|.|; s|/[^/]*$$||; s|$$|/so_locations|' | \
 	      sort -u`; \
 	test -z "$$locs" || { \
 	  echo rm -f $${locs}; \
 	  rm -f $${locs}; \
 	}
 
 libexpat.la: $(libexpat_la_OBJECTS) $(libexpat_la_DEPENDENCIES) $(EXTRA_libexpat_la_DEPENDENCIES) 
 	$(AM_V_CCLD)$(libexpat_la_LINK) -rpath $(libdir) $(libexpat_la_OBJECTS) $(libexpat_la_LIBADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 
 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 $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
 
 .c.obj:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .c.lo:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 install-docDATA: $(doc_DATA)
 	@$(NORMAL_INSTALL)
 	@list='$(doc_DATA)'; test -n "$(docdir)" || list=; \
 	if test -n "$$list"; then \
 	  echo " $(MKDIR_P) '$(DESTDIR)$(docdir)'"; \
 	  $(MKDIR_P) "$(DESTDIR)$(docdir)" || exit 1; \
 	fi; \
 	for p in $$list; do \
 	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
 	  echo "$$d$$p"; \
 	done | $(am__base_list) | \
 	while read files; do \
 	  echo " $(INSTALL_DATA) $$files '$(DESTDIR)$(docdir)'"; \
 	  $(INSTALL_DATA) $$files "$(DESTDIR)$(docdir)" || exit $$?; \
 	done
 
 uninstall-docDATA:
 	@$(NORMAL_UNINSTALL)
 	@list='$(doc_DATA)'; test -n "$(docdir)" || list=; \
 	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
 	dir='$(DESTDIR)$(docdir)'; $(am__uninstall_files_from_dir)
 install-includeHEADERS: $(include_HEADERS)
 	@$(NORMAL_INSTALL)
 	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
 	if test -n "$$list"; then \
 	  echo " $(MKDIR_P) '$(DESTDIR)$(includedir)'"; \
 	  $(MKDIR_P) "$(DESTDIR)$(includedir)" || exit 1; \
 	fi; \
 	for p in $$list; do \
 	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
 	  echo "$$d$$p"; \
 	done | $(am__base_list) | \
 	while read files; do \
 	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includedir)'"; \
 	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(includedir)" || exit $$?; \
 	done
 
 uninstall-includeHEADERS:
 	@$(NORMAL_UNINSTALL)
 	@list='$(include_HEADERS)'; test -n "$(includedir)" || list=; \
 	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
 	dir='$(DESTDIR)$(includedir)'; $(am__uninstall_files_from_dir)
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-am
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-am
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscopelist: cscopelist-am
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 check-am: all-am
 check: check-am
 all-am: Makefile $(LTLIBRARIES) $(DATA) $(HEADERS)
 installdirs:
 	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(docdir)" "$(DESTDIR)$(includedir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
 install: install-am
 install-exec: install-exec-am
 install-data: install-data-am
 uninstall: uninstall-am
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-am
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-am
 
 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
 
 dvi: dvi-am
 
 dvi-am:
 
 html: html-am
 
 html-am:
 
 info: info-am
 
 info-am:
 
 install-data-am: install-docDATA install-includeHEADERS
 	@$(NORMAL_INSTALL)
 	$(MAKE) $(AM_MAKEFLAGS) install-data-hook
 install-dvi: install-dvi-am
 
 install-dvi-am:
 
 install-exec-am: install-libLTLIBRARIES
 
 install-html: install-html-am
 
 install-html-am:
 
 install-info: install-info-am
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-am
 
 install-pdf-am:
 
 install-ps: install-ps-am
 
 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
 
 mostlyclean: mostlyclean-am
 
 mostlyclean-am: mostlyclean-compile mostlyclean-generic \
 	mostlyclean-libtool
 
 pdf: pdf-am
 
 pdf-am:
 
 ps: ps-am
 
 ps-am:
 
 uninstall-am: uninstall-docDATA uninstall-includeHEADERS \
 	uninstall-libLTLIBRARIES uninstall-local
 
 .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 \
 	install-dvi-am install-exec install-exec-am install-html \
 	install-html-am install-includeHEADERS install-info \
 	install-info-am install-libLTLIBRARIES install-man install-pdf \
 	install-pdf-am install-ps install-ps-am install-strip \
 	installcheck installcheck-am installdirs maintainer-clean \
 	maintainer-clean-generic mostlyclean mostlyclean-compile \
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	tags tags-am uninstall uninstall-am uninstall-docDATA \
 	uninstall-includeHEADERS uninstall-libLTLIBRARIES \
 	uninstall-local
 
 .PRECIOUS: Makefile
 
 
 install-data-hook:
 	cd "$(DESTDIR)$(docdir)" && $(am__mv) Changes changelog
 
 uninstall-local:
 	$(RM) "$(DESTDIR)$(docdir)/changelog"
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/lib/asciitab.h
===================================================================
--- vendor/expat/dist/lib/asciitab.h	(revision 355070)
+++ vendor/expat/dist/lib/asciitab.h	(revision 355071)
@@ -1,64 +1,64 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 /* 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,
Index: vendor/expat/dist/lib/expat.h
===================================================================
--- vendor/expat/dist/lib/expat.h	(revision 355070)
+++ vendor/expat/dist/lib/expat.h	(revision 355071)
@@ -1,1085 +1,1024 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 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
    stanza can be added to code that still needs to support older
    versions of Expat 1.95.x:
 
    #ifndef XML_STATUS_OK
    #define XML_STATUS_OK    1
    #define XML_STATUS_ERROR 0
    #endif
 
    Otherwise, the #define hackery is quite ugly and would have been
    dropped.
 */
 enum XML_Status {
   XML_STATUS_ERROR = 0,
 #define XML_STATUS_ERROR XML_STATUS_ERROR
   XML_STATUS_OK = 1,
 #define XML_STATUS_OK XML_STATUS_OK
   XML_STATUS_SUSPENDED = 2
 #define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
 };
 
 enum XML_Error {
   XML_ERROR_NONE,
   XML_ERROR_NO_MEMORY,
   XML_ERROR_SYNTAX,
   XML_ERROR_NO_ELEMENTS,
   XML_ERROR_INVALID_TOKEN,
   XML_ERROR_UNCLOSED_TOKEN,
   XML_ERROR_PARTIAL_CHAR,
   XML_ERROR_TAG_MISMATCH,
   XML_ERROR_DUPLICATE_ATTRIBUTE,
   XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
   XML_ERROR_PARAM_ENTITY_REF,
   XML_ERROR_UNDEFINED_ENTITY,
   XML_ERROR_RECURSIVE_ENTITY_REF,
   XML_ERROR_ASYNC_ENTITY,
   XML_ERROR_BAD_CHAR_REF,
   XML_ERROR_BINARY_ENTITY_REF,
   XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
   XML_ERROR_MISPLACED_XML_PI,
   XML_ERROR_UNKNOWN_ENCODING,
   XML_ERROR_INCORRECT_ENCODING,
   XML_ERROR_UNCLOSED_CDATA_SECTION,
   XML_ERROR_EXTERNAL_ENTITY_HANDLING,
   XML_ERROR_NOT_STANDALONE,
   XML_ERROR_UNEXPECTED_STATE,
   XML_ERROR_ENTITY_DECLARED_IN_PE,
   XML_ERROR_FEATURE_REQUIRES_XML_DTD,
   XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
   /* Added in 1.95.7. */
   XML_ERROR_UNBOUND_PREFIX,
   /* Added in 1.95.8. */
   XML_ERROR_UNDECLARING_PREFIX,
   XML_ERROR_INCOMPLETE_PE,
   XML_ERROR_XML_DECL,
   XML_ERROR_TEXT_DECL,
   XML_ERROR_PUBLICID,
   XML_ERROR_SUSPENDED,
   XML_ERROR_NOT_SUSPENDED,
   XML_ERROR_ABORTED,
   XML_ERROR_FINISHED,
   XML_ERROR_SUSPEND_PE,
   /* Added in 2.0. */
   XML_ERROR_RESERVED_PREFIX_XML,
   XML_ERROR_RESERVED_PREFIX_XMLNS,
   XML_ERROR_RESERVED_NAMESPACE_URI,
   /* Added in 2.2.1. */
   XML_ERROR_INVALID_ARGUMENT
 };
 
 enum XML_Content_Type {
   XML_CTYPE_EMPTY = 1,
   XML_CTYPE_ANY,
   XML_CTYPE_MIXED,
   XML_CTYPE_NAME,
   XML_CTYPE_CHOICE,
   XML_CTYPE_SEQ
 };
 
 enum XML_Content_Quant {
   XML_CQUANT_NONE,
   XML_CQUANT_OPT,
   XML_CQUANT_REP,
   XML_CQUANT_PLUS
 };
 
 /* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
    XML_CQUANT_NONE, and the other fields will be zero or NULL.
    If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
    numchildren will contain number of elements that may be mixed in
    and children point to an array of XML_Content cells that will be
    all of XML_CTYPE_NAME type with no quantification.
 
    If type == XML_CTYPE_NAME, then the name points to the name, and
    the numchildren field will be zero and children will be NULL. The
    quant fields indicates any quantifiers placed on the name.
 
    CHOICE and SEQ will have name NULL, the number of children in
    numchildren and children will point, recursively, to an array
    of XML_Content cells.
 
    The EMPTY, ANY, and MIXED types will only occur at top level.
 */
 
 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
    generate multiple calls to this handler. The "default" parameter
    may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
    keyword. The "isrequired" parameter will be true and the default
    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
    parameter will be NULL for text declarations. The encoding
    parameter may be NULL for XML declarations. The standalone
    parameter will be -1, 0, or 1 indicating respectively that there
    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);
   void *(*realloc_fcn)(void *ptr, size_t size);
   void (*free_fcn)(void *ptr);
 } XML_Memory_Handling_Suite;
 
 /* Constructs a new parser; encoding is the encoding specified by the
    external protocol or NULL if there is none specified.
 */
 XMLPARSEAPI(XML_Parser)
 XML_ParserCreate(const XML_Char *encoding);
 
 /* Constructs a new parser and namespace processor.  Element type
    names and attribute names that belong to a namespace will be
    expanded; unprefixed attribute names are never expanded; unprefixed
    element type names are expanded only if there is a default
    namespace. The expanded name is the concatenation of the namespace
    URI, the namespace separator character, and the local part of the
    name.  If the namespace separator is '\0' then the namespace URI
    and the local part will be concatenated without any separator.
    It is a programming error to use the separator '\0' with namespace
    triplets (see XML_SetReturnNSTriplet).
 */
 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
    namespace processing as described above. The character pointed at
    will serve as the namespace separator.
 
    All further memory operations used for the created parser will come from
    the given suite.
 */
 XMLPARSEAPI(XML_Parser)
 XML_ParserCreate_MM(const XML_Char *encoding,
                     const XML_Memory_Handling_Suite *memsuite,
                     const XML_Char *namespaceSeparator);
 
 /* Prepare a parser object to be re-used.  This is particularly
    valuable when memory allocation overhead is disproportionately high,
    such as when a large number of small documnents need to be parsed.
    All handlers are cleared from the parser, except for the
    unknownEncodingHandler. The parser's external state is re-initialized
    except for the values of ns and ns_triplets.
 
    Added in Expat 1.95.3.
 */
 XMLPARSEAPI(XML_Bool)
 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_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_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
    are part of markup which is of a kind that is not reported
    (comments, markup declarations), or characters that are part of a
    construct which could be reported but for which no handler has been
    supplied. The characters are passed exactly as they were in the XML
    document except that they will be encoded in UTF-8 or UTF-16.
    Line boundaries are not normalized. Note that a byte order mark
    character is not passed to the default handler. There are no
    guarantees about how characters are divided between calls to the
    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
    otherwise.
 
    For internal entities (<!ENTITY foo "bar">), value will
    be non-NULL and systemId, publicID, and notationName will be NULL.
    The value string is NOT nul-terminated; the length is provided in
    the value_length argument. Since it is legal to have zero-length
    values, do not use this argument to test for internal entities.
 
    For external entities, value will be NULL and systemId will be
    non-NULL. The publicId argument will be NULL unless a public
    identifier was provided. The notationName argument will have a
    non-NULL value only for unparsed entity declarations.
 
    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.
    It is provided here for backward compatibility.
 
    This is called for a declaration of an unparsed (NDATA) entity.
    The base argument is whatever was set by XML_SetBase. The
    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
    handlers occur between the calls to the start and end namespace
    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
    have standalone="yes". If this handler returns XML_STATUS_ERROR,
    then processing will not continue, and the parser will return a
    XML_ERROR_NOT_STANDALONE error.
    If parameter entity parsing is enabled, then in addition to the
    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
    application can parse it immediately or later using
    XML_ExternalEntityParserCreate.
 
    The parser argument is the parser parsing the entity containing the
    reference; it can be passed as the parser argument to
    XML_ExternalEntityParserCreate.  The systemId argument is the
    system identifier as specified in the entity declaration; it will
    not be NULL.
 
    The base argument is the system identifier that should be used as
    the base for resolving systemId if systemId was relative; this is
    set by XML_SetBase; it may be NULL.
 
    The publicId argument is the public identifier as specified in the
    entity declaration, or NULL if none was specified; the whitespace
    in the public identifier will have been normalized as required by
    the XML spec.
 
    The context argument specifies the parsing context in the format
    expected by the context argument to XML_ExternalEntityParserCreate;
    context is valid only until the handler returns, so if the
    referenced entity is to be parsed later, it must be copied.
    context is NULL only when the entity is a parameter entity.
 
    The handler should return XML_STATUS_ERROR if processing should not
    continue because of a fatal error in the handling of the external
    entity.  In this case the calling parser will return an
    XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
 
    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
       has been read *and* this is not an error.
    2) An internal entity reference is read, but not expanded, because
       XML_SetDefaultHandler has been called.
    Note: skipped parameter entities in declarations and skipped general
          entities in attribute values cannot be reported, because
          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
    to the parser.
 
    The map[b] member gives information about byte sequences whose
    first byte is b.
 
    If map[b] is c where c is >= 0, then b by itself encodes the
    Unicode scalar value c.
 
    If map[b] is -1, then the byte sequence is malformed.
 
    If map[b] is -n, where n >= 2, then b is the first byte of an
    n-byte sequence that encodes a single Unicode scalar value.
 
    The data member will be passed as the first argument to the convert
    function.
 
    The convert function is used to convert multibyte sequences; s will
    point to a n-byte sequence where map[(unsigned char)*s] == -n.  The
    convert function must return the Unicode scalar value represented
    by this byte sequence or -1 if the byte sequence is malformed.
 
    The convert function may be NULL if the encoding is a single-byte
    encoding, that is if map[b] >= -1 for all bytes b.
 
    When the parser is finished with the encoding, then if release is
    not NULL, it will call release passing it the data member; once
    release has been called, the convert function will not be called
    again.
 
    Expat places certain restrictions on the encodings that are supported
    using this mechanism.
 
    1. Every ASCII character that can appear in a well-formed XML document,
       other than the characters
 
       $@\^`{}~
 
       must be represented by a single byte, and that byte must be the
       same byte that represents that character in ASCII.
 
    2. No character may require more than 4 bytes to encode.
 
    3. All characters encoded must have Unicode scalar values <=
       0xFFFF, (i.e., characters that would be encoded by surrogates in
       UTF-16 are  not allowed).  Note that this restriction doesn't
       apply to the built-in support for UTF-8 and UTF-16.
 
    4. No Unicode character may be encoded by more than one distinct
       sequence of bytes.
 */
 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.
 
    The encodingHandlerData argument is that which was passed as the
    second argument to XML_SetUnknownEncodingHandler.
 
    The name argument gives the name of the encoding as specified in
    the encoding declaration.
 
    If the callback can provide information about the encoding, it must
    fill in the XML_Encoding structure, and return XML_STATUS_OK.
    Otherwise it must return XML_STATUS_ERROR.
 
    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,
                             XML_CharacterDataHandler handler);
 
 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,
                            XML_StartCdataSectionHandler start,
                            XML_EndCdataSectionHandler end);
 
 XMLPARSEAPI(void)
 XML_SetStartCdataSectionHandler(XML_Parser parser,
                                 XML_StartCdataSectionHandler start);
 
 XMLPARSEAPI(void)
 XML_SetEndCdataSectionHandler(XML_Parser parser,
                               XML_EndCdataSectionHandler end);
 
 /* This sets the default handler and also inhibits expansion of
    internal entities. These entity references will be passed to the
    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)
 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,
                             XML_StartNamespaceDeclHandler start,
                             XML_EndNamespaceDeclHandler end);
 
 XMLPARSEAPI(void)
 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
                                  XML_StartNamespaceDeclHandler start);
 
 XMLPARSEAPI(void)
 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
                                XML_EndNamespaceDeclHandler end);
 
 XMLPARSEAPI(void)
 XML_SetNotStandaloneHandler(XML_Parser parser,
                             XML_NotStandaloneHandler handler);
 
 XMLPARSEAPI(void)
 XML_SetExternalEntityRefHandler(XML_Parser parser,
                                 XML_ExternalEntityRefHandler handler);
 
 /* If a non-NULL value for arg is specified here, then it will be
    passed as the first argument to the external entity ref handler
    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,
                             XML_SkippedEntityHandler handler);
 
 XMLPARSEAPI(void)
 XML_SetUnknownEncodingHandler(XML_Parser parser,
                               XML_UnknownEncodingHandler handler,
                               void *encodingHandlerData);
 
 /* This can be called within a handler for a start element, end
    element, processing instruction or character data.  It causes the
    corresponding markup to be passed to the default handler.
 */
 XMLPARSEAPI(void)
 XML_DefaultCurrent(XML_Parser parser);
 
 /* If do_nst is non-zero, and namespace processing is in effect, and
    a name has a prefix (i.e. an explicit namespace qualifier) then
    that name is returned as a triplet in a single string separated by
    the separator character specified when the parser was created: URI
    + sep + local_name + sep + prefix.
 
    If do_nst is zero, then namespace information is returned in the
    default manner (URI + sep + local_name) whether or not the name
    has a prefix.
 
    Note: Calling XML_SetReturnNSTriplet after XML_Parse or
      XML_ParseBuffer has no effect.
 */
 
 XMLPARSEAPI(void)
 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
 
 /* This value is passed as the userData argument to callbacks. */
 XMLPARSEAPI(void)
 XML_SetUserData(XML_Parser parser, void *userData);
 
 /* Returns the last value set by XML_SetUserData or NULL. */
 #define XML_GetUserData(parser) (*(void **)(parser))
 
 /* This is equivalent to supplying an encoding argument to
    XML_ParserCreate. On success XML_SetEncoding returns non-zero,
    zero otherwise.
    Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
      has no effect and returns XML_STATUS_ERROR.
 */
 XMLPARSEAPI(enum XML_Status)
 XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
 
 /* If this function is called, then the parser will be passed as the
    first argument to callbacks instead of userData.  The userData will
    still be accessible using XML_GetUserData.
 */
 XMLPARSEAPI(void)
 XML_UseParserAsHandlerArg(XML_Parser parser);
 
 /* If useDTD == XML_TRUE is passed to this function, then the parser
    will assume that there is an external subset, even if none is
    specified in the document. In such a case the parser will call the
    externalEntityRefHandler with a value of NULL for the systemId
    argument (the publicId and context arguments will be NULL as well).
    Note: For the purpose of checking WFC: Entity Declared, passing
      useDTD == XML_TRUE will make the parser behave as if the document
      had a DTD with an external subset.
    Note: If this function is called, then this must be done before
      the first call to XML_Parse or XML_ParseBuffer, since it will
      have no effect after that.  Returns
      XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
    Note: If the document does not have a DOCTYPE declaration at all,
      then startDoctypeDeclHandler and endDoctypeDeclHandler will not
      be called, despite an external subset being parsed.
    Note: If XML_DTD is not defined when Expat is compiled, returns
      XML_ERROR_FEATURE_REQUIRES_XML_DTD.
    Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
 */
 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
    base argument to the XML_ExternalEntityRefHandler,
    XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
    argument will be copied.  Returns XML_STATUS_ERROR if out of memory,
    XML_STATUS_OK otherwise.
 */
 XMLPARSEAPI(enum XML_Status)
 XML_SetBase(XML_Parser parser, const XML_Char *base);
 
 XMLPARSEAPI(const XML_Char *)
 XML_GetBase(XML_Parser parser);
 
 /* Returns the number of the attribute/value pairs passed in last call
    to the XML_StartElementHandler that were specified in the start-tag
    rather than defaulted. Each attribute/value pair counts as 2; thus
    this correspondds to an index into the atts array passed to the
    XML_StartElementHandler.  Returns -1 if parser == NULL.
 */
 XMLPARSEAPI(int)
 XML_GetSpecifiedAttributeCount(XML_Parser parser);
 
 /* Returns the index of the ID attribute passed in the last call to
    XML_StartElementHandler, or -1 if there is no ID attribute or
    parser == NULL.  Each attribute/value pair counts as 2; thus this
    correspondds to an index into the atts array passed to the
    XML_StartElementHandler.
 */
 XMLPARSEAPI(int)
 XML_GetIdAttributeIndex(XML_Parser parser);
 
 #ifdef XML_ATTR_INFO
 /* Source file byte offsets for the start and end of attribute names and values.
    The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
    file an attribute value of "blah" will yield:
    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
    passed in last call to the XML_StartElementHandler that were specified
    in the start-tag rather than defaulted. Each attribute/value pair counts
    as 1; thus the number of entries in the array is
    XML_GetSpecifiedAttributeCount(parser) / 2.
 */
 XMLPARSEAPI(const XML_AttrInfo *)
 XML_GetAttributeInfo(XML_Parser parser);
 #endif
 
 /* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
    detected.  The last call to XML_Parse must have isFinal true; len
    may be zero for this call (or any other).
 
    Though the return values for these functions has always been
    described as a Boolean value, the implementation, at least for the
    1.95.x series, has always returned exactly one of the XML_Status
    values.
 */
 XMLPARSEAPI(enum XML_Status)
 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
 
 XMLPARSEAPI(void *)
 XML_GetBuffer(XML_Parser parser, int len);
 
 XMLPARSEAPI(enum XML_Status)
 XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
 
 /* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
    Must be called from within a call-back handler, except when aborting
    (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.
 
    *Note*:
    This will be applied to the current parser instance only, that is, if
    there is a parent parser then it will continue parsing when the
    externalEntityRefHandler() returns. It is up to the implementation of
    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);
 
 /* 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
    first, and on its parent parser only after the child parser has finished,
    to be applied recursively until the document entity's parser is restarted.
    That is, the parent parser will not resume by itself and it is up to the
    application to call XML_ResumeParser() on it at the appropriate moment.
 */
 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;
   XML_Bool finalBuffer;
 } XML_ParsingStatus;
 
 /* Returns status of parser with respect to being initialized, parsing,
    finished, or suspended and processing the final buffer.
    XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
    XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
 */
 XMLPARSEAPI(void)
 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
 
 /* Creates an XML_Parser object that can parse an external general
    entity; context is a '\0'-terminated string specifying the parse
    context; encoding is a '\0'-terminated string giving the name of
    the externally specified encoding, or NULL if there is no
    externally specified encoding.  The context string consists of a
    sequence of tokens separated by formfeeds (\f); a token consisting
    of a name specifies that the general entity of the name is open; a
    token of the form prefix=uri specifies the namespace for a
    particular prefix; a token of the form =uri specifies the default
    namespace.  This can be called at any point after the first call to
    an ExternalEntityRefHandler so longer as the parser has not yet
    been freed.  The new parser is completely independent and may
    safely be used in a separate thread.  The handlers and userData are
    initialized from the parser argument.  Returns NULL if out of memory.
    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 {
   XML_PARAM_ENTITY_PARSING_NEVER,
   XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
   XML_PARAM_ENTITY_PARSING_ALWAYS
 };
 
 /* Controls parsing of parameter entities (including the external DTD
    subset). If parsing of parameter entities is enabled, then
    references to external parameter entities (including the external
    DTD subset) will be passed to the handler set with
    XML_SetExternalEntityRefHandler.  The context passed will be 0.
 
    Unlike external general entities, external parameter entities can
    only be parsed synchronously.  If the external parameter entity is
    to be parsed, it must be parsed during the call to the external
    entity ref handler: the complete sequence of
    XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
    XML_ParserFree calls must be made during this call.  After
    XML_ExternalEntityParserCreate has been called to create the parser
    for the external parameter entity (context must be 0 for this
    call), it is illegal to make any calls on the old parser until
    XML_ParserFree has been called on the newly created parser.
    If the library has been compiled without support for parameter
    entity parsing (ie without XML_DTD being defined), then
    XML_SetParamEntityParsing will return 0 if parsing of parameter
    entities is requested; otherwise it will return non-zero.
    Note: If XML_SetParamEntityParsing is called after XML_Parse or
       XML_ParseBuffer, then it has no effect and will always return 0.
    Note: If parser == NULL, the function will do nothing and return 0.
 */
 XMLPARSEAPI(int)
 XML_SetParamEntityParsing(XML_Parser parser,
                           enum XML_ParamEntityParsing parsing);
 
 /* Sets the hash salt to use for internal hash calculations.
    Helps in preventing DoS attacks based on predicting hash
    function behavior. This must be called before parsing is started.
    Returns 1 if successful, 0 when called after parsing has started.
    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.
 */
 XMLPARSEAPI(enum XML_Error)
 XML_GetErrorCode(XML_Parser parser);
 
 /* These functions return information about the current parse
    location.  They may be called from any callback called to report
    some parse event; in this case the location is the location of the
    first of the sequence of characters that generated the event.  When
    called from callbacks generated by declarations in the document
    prologue, the location identified isn't as neatly defined, but will
    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
    was detected; otherwise the location is the location of the last
    parse event, as described above.
 
    Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
    return 0 to indicate an error.
    Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
 */
 XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
 XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
 XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
 
 /* Return the number of bytes in the current event.
    Returns 0 if the event is in an internal entity.
 */
 XMLPARSEAPI(int)
 XML_GetCurrentByteCount(XML_Parser parser);
 
 /* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
    the integer pointed to by offset to the offset within this buffer
    of the current parse position, and sets the integer pointed to by size
    to the size of this buffer (the number of input bytes). Otherwise
    returns a NULL pointer. Also returns a NULL pointer if a parse isn't
    active.
 
    NOTE: The character pointer returned should not be used outside
    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)
 XML_FreeContentModel(XML_Parser parser, XML_Content *model);
 
 /* Exposing the memory handling functions used in Expat */
 XMLPARSEAPI(void *)
 XML_ATTR_MALLOC
 XML_ATTR_ALLOC_SIZE(2)
 XML_MemMalloc(XML_Parser parser, size_t size);
 
 XMLPARSEAPI(void *)
 XML_ATTR_ALLOC_SIZE(3)
 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
 
 XMLPARSEAPI(void)
 XML_MemFree(XML_Parser parser, void *ptr);
 
 /* Frees memory used by the parser. */
 XMLPARSEAPI(void)
 XML_ParserFree(XML_Parser parser);
 
 /* Returns a string describing the error. */
 XMLPARSEAPI(const XML_LChar *)
 XML_ErrorString(enum XML_Error code);
 
 /* Return a string containing the version number of this expat */
 XMLPARSEAPI(const XML_LChar *)
 XML_ExpatVersion(void);
 
 typedef struct {
   int major;
   int minor;
   int micro;
 } XML_Expat_Version;
 
 /* Return an XML_Expat_Version structure containing numeric version
    number information for this version of expat.
 */
 XMLPARSEAPI(XML_Expat_Version)
 XML_ExpatVersionInfo(void);
 
 /* Added in Expat 1.95.5. */
 enum XML_FeatureEnum {
   XML_FEATURE_END = 0,
   XML_FEATURE_UNICODE,
   XML_FEATURE_UNICODE_WCHAR_T,
   XML_FEATURE_DTD,
   XML_FEATURE_CONTEXT_BYTES,
   XML_FEATURE_MIN_SIZE,
   XML_FEATURE_SIZEOF_XML_CHAR,
   XML_FEATURE_SIZEOF_XML_LCHAR,
   XML_FEATURE_NS,
   XML_FEATURE_LARGE_SIZE,
   XML_FEATURE_ATTR_INFO
   /* Additional features must be added to the end of this enum. */
 };
 
 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
 }
 #endif
 
 #endif /* not Expat_INCLUDED */
Index: vendor/expat/dist/lib/expat_external.h
===================================================================
--- vendor/expat/dist/lib/expat_external.h	(revision 355070)
+++ vendor/expat/dist/lib/expat_external.h	(revision 355071)
@@ -1,162 +1,158 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifndef Expat_External_INCLUDED
 #define Expat_External_INCLUDED 1
 
 /* 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
    achieve some different behavior, but doing so it not recommended or
    tested frequently.
 
    XMLCALL    - The calling convention to use for all calls across the
                 "library boundary."  This will default to cdecl, and
                 try really hard to tell the compiler that's what we
                 want.
 
    XMLIMPORT  - Whatever magic is needed to note that a function is
                 to be imported from a dynamically loaded library
                 (.dll, .so, or .sl, depending on your platform).
 
    The XMLCALL macro was added in Expat 1.95.7.  The only one which is
    expected to be directly useful in client code is XMLCALL.
 
    Note that on at least some Unix versions, the Expat library must be
    compiled with the cdecl calling convention as the default since
    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
    do so.
 
    If this is the case for your platform, please file a bug report
    with information on how to identify your platform via the C
    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
 
 #ifdef __cplusplus
 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;
 #endif /* XML_LARGE_SIZE */
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif /* not Expat_External_INCLUDED */
Index: vendor/expat/dist/lib/iasciitab.h
===================================================================
--- vendor/expat/dist/lib/iasciitab.h	(revision 355070)
+++ vendor/expat/dist/lib/iasciitab.h	(revision 355071)
@@ -1,65 +1,65 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 /* 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,
Index: vendor/expat/dist/lib/internal.h
===================================================================
--- vendor/expat/dist/lib/internal.h	(revision 355070)
+++ vendor/expat/dist/lib/internal.h	(revision 355071)
@@ -1,124 +1,123 @@
 /* internal.h
 
    Internal definitions used by Expat.  This is not needed to compile
    client code.
 
    The following calling convention macros are defined for frequently
    called functions:
 
    FASTCALL    - Used for those internal functions that have a simple
                  body and a low number of arguments and local variables.
 
    PTRCALL     - Used for functions called though function pointers.
 
    PTRFASTCALL - Like PTRCALL, but for low number of arguments.
 
    inline      - Used for selected internal functions for which inlining
                  may improve performance on some platforms.
 
    Note: Use of these macros is based on judgement, not hard rules,
          and therefore subject to change.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
-#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.
 
    Instability reported with egcs on a RedHat Linux 7.3.
    Let's comment out:
    #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
    MS VC++, especially for function pointers, so we won't use it for
    now on that platform. It may be reconsidered for a future release
    if it can be made more effective.
    Likely reason: __fastcall on Windows is like stdcall, therefore
    the compiler cannot perform stack optimizations for call clusters.
 */
 
 /* 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
+#  ifndef inline
+#    define inline
+#  endif
 #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
 }
 #endif
Index: vendor/expat/dist/lib/latin1tab.h
===================================================================
--- vendor/expat/dist/lib/latin1tab.h	(revision 355070)
+++ vendor/expat/dist/lib/latin1tab.h	(revision 355071)
@@ -1,64 +1,64 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 /* 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,
Index: vendor/expat/dist/lib/nametab.h
===================================================================
--- vendor/expat/dist/lib/nametab.h	(revision 355070)
+++ vendor/expat/dist/lib/nametab.h	(revision 355071)
@@ -1,182 +1,136 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 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,
 };
Index: vendor/expat/dist/lib/siphash.h
===================================================================
--- vendor/expat/dist/lib/siphash.h	(revision 355070)
+++ vendor/expat/dist/lib/siphash.h	(revision 355071)
@@ -1,391 +1,398 @@
 /* ==========================================================================
  * siphash.h - SipHash-2-4 in a single header file
  * --------------------------------------------------------------------------
  * Derived by William Ahern from the reference implementation[1] published[2]
  * by Jean-Philippe Aumasson and Daniel J. Berstein.
  * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
  * Licensed under the CC0 Public Domain Dedication license.
  *
  * 1. https://www.131002.net/siphash/siphash24.c
  * 2. https://www.131002.net/siphash/
  * --------------------------------------------------------------------------
  * 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
  *
  * 2017-11-03  (Sebastian Pipping)
  *   - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
  *
  * 2017-07-25  (Vadim Zeitlin)
  *   - Fix use of SIPHASH_MAIN macro
  *
  * 2017-07-05  (Sebastian Pipping)
  *   - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
  *   - Add const qualifiers at two places
  *   - Ensure <=80 characters line length (assuming tab width 4)
  *
  * 2017-06-23  (Victor Stinner)
  *   - Address Win64 compile warnings
  *
  * 2017-06-18  (Sebastian Pipping)
  *   - Clarify license note in the header
  *   - Address C89 issues:
  *     - Stop using inline keyword (and let compiler decide)
  *     - Replace _Bool by int
  *     - Turn macro siphash24 into a function
  *     - Address invalid conversion (void pointer) by explicit cast
  *   - Address lack of stdint.h for Visual Studio 2003 to 2008
  *   - Always expose sip24_valid (for self-tests)
  *
  * 2012-11-04 - Born.  (William Ahern)
  * --------------------------------------------------------------------------
  * USAGE:
  *
  * SipHash-2-4 takes as input two 64-bit words as the key, some number of
  * message bytes, and outputs a 64-bit word as the message digest. This
  * implementation employs two data structures: a struct sipkey for
  * representing the key, and a struct siphash for representing the hash
  * state.
  *
  * For converting a 16-byte unsigned char array to a key, use either the
  * macro sip_keyof or the routine sip_tokey. The former instantiates a
  * compound literal key, while the latter requires a key object as a
  * parameter.
  *
  * 	unsigned char secret[16];
  * 	arc4random_buf(secret, sizeof secret);
  * 	struct sipkey *key = sip_keyof(secret);
  *
  * For hashing a message, use either the convenience macro siphash24 or the
  * routines sip24_init, sip24_update, and sip24_final.
  *
  * 	struct siphash state;
  * 	void *msg;
  * 	size_t len;
  * 	uint64_t hash;
  *
  * 	sip24_init(&state, key);
  * 	sip24_update(&state, msg, len);
  * 	hash = sip24_final(&state);
  *
  * or
  *
  * 	hash = siphash24(msg, len, key);
  *
  * To convert the 64-bit hash value to a canonical 8-byte little-endian
  * binary representation, use either the macro sip_binof or the routine
  * sip_tobin. The former instantiates and returns a compound literal array,
  * while the latter requires an array object as a parameter.
  * --------------------------------------------------------------------------
  * NOTES:
  *
  * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
  *   lacking compound literal support. Instead, you must use the lower-level
  *   interfaces which take as parameters the temporary state objects.
  *
  * o Uppercase macros may evaluate parameters more than once. Lowercase
  *   macros should not exhibit any such side effects.
  * ==========================================================================
  */
 #ifndef SIPHASH_H
 #define SIPHASH_H
 
 #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_ULL(high, low) (((uint64_t)high << 32) | low)
 
+#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
 
-#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ( (x) >> (64 - (b))))
+#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_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_U64TO8_LE(p, v)                                                    \
+  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
+  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
 
-#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 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;
 
-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;
+  }
 
-	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);
 
-	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;
+  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 ...
  * and
  * in = (empty string)
  * in = 00 (1 byte)
  * in = 00 01 (2 bytes)
  * in = 00 01 02 (3 bytes)
  * ...
  * 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;
+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 */
 
-	sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
-			"\012\013\014\015\016\017");
+  unsigned char in[64];
+  struct sipkey k;
+  size_t i;
 
-	for (i = 0; i < sizeof in; ++i) {
-		in[i] = (unsigned char)i;
+  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
+                "\012\013\014\015\016\017");
 
-		if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
-			return 0;
-	}
+  for (i = 0; i < sizeof in; ++i) {
+    in[i] = (unsigned char)i;
 
-	return 1;
+    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 */
Index: vendor/expat/dist/lib/utf8tab.h
===================================================================
--- vendor/expat/dist/lib/utf8tab.h	(revision 355070)
+++ vendor/expat/dist/lib/utf8tab.h	(revision 355071)
@@ -1,64 +1,64 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 /* 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,
Index: vendor/expat/dist/lib/xmlparse.c
===================================================================
--- vendor/expat/dist/lib/xmlparse.c	(revision 355070)
+++ vendor/expat/dist/lib/xmlparse.c	(revision 355071)
@@ -1,7217 +1,6895 @@
-/* 19ac4776051591216f1874e34ee99b6a43a3784c8bd7d70efeb9258dd22b906a (2.2.6+)
+/* f519f27c7c3b79fee55aeb8b1e53b7384b079d9118bf3a62eb3a60986a6742f2 (2.2.9+)
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
-#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"
 #include "expat.h"
 #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_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_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: \
       * Linux + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \
       * Linux + glibc <2.25 (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \
       * BSD / macOS >=10.7 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \
       * BSD / macOS <10.7 (arc4random): HAVE_ARC4RANDOM, \
       * 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. \
     \
     If you have reasons to patch this detection code away or need changes \
     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"
 
 typedef const XML_Char *KEY;
 
 typedef struct {
   KEY name;
 } NAMED;
 
 typedef struct {
   NAMED **v;
   unsigned char power;
   size_t size;
   size_t used;
   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,
    since we can calculate a second hash value cheaply by taking those bits
    of the first hash value that were discarded (masked out) when the table
    index was calculated: index = hash & mask, where mask = table->size - 1.
    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 {
   NAMED **p;
   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
 #define INIT_BLOCK_SIZE 1024
 #define INIT_BUFFER_SIZE 1024
 
 #define EXPAND_SPARE 24
 
 typedef struct binding {
   struct prefix *prefix;
   struct binding *nextTagBinding;
   struct binding *prevPrefixBinding;
   const struct attribute_id *attId;
   XML_Char *uri;
   int uriLen;
   int uriAlloc;
 } BINDING;
 
 typedef struct prefix {
   const XML_Char *name;
   BINDING *binding;
 } PREFIX;
 
 typedef struct {
   const XML_Char *str;
   const XML_Char *localPart;
   const XML_Char *prefix;
   int strLen;
   int uriLen;
   int prefixLen;
 } TAG_NAME;
 
 /* TAG represents an open element.
    The name of the element is stored in both the document and API
    encodings.  The memory buffer 'buf' is a separately-allocated
    memory area which stores the name.  During the XML_Parse()/
    XMLParseBuffer() when the element is open, the memory for the 'raw'
    version of the name (in the document encoding) is shared with the
    document buffer.  If the element is open across calls to
    XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
    contain the 'raw' name as well.
 
    A parser re-uses these structures, maintaining a list of allocated
    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;
   const XML_Char *notation;
   XML_Bool open;
   XML_Bool is_param;
   XML_Bool is_internal; /* true if declared in internal subset outside PE */
 } 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
 
 typedef struct block {
   struct block *next;
   int size;
   XML_Char s[1];
 } BLOCK;
 
 typedef struct {
   BLOCK *blocks;
   BLOCK *freeBlocks;
   const XML_Char *end;
   XML_Char *ptr;
   XML_Char *start;
   const XML_Memory_Handling_Suite *mem;
 } STRING_POOL;
 
 /* The XML_Char before the name is used to determine whether
    an attribute has been specified. */
 typedef struct attribute_id {
   XML_Char *name;
   PREFIX *prefix;
   XML_Bool maybeTokenized;
   XML_Bool xmlns;
 } ATTRIBUTE_ID;
 
 typedef struct {
   const ATTRIBUTE_ID *id;
   XML_Bool isCdata;
   const XML_Char *value;
 } DEFAULT_ATTRIBUTE;
 
 typedef struct {
   unsigned long version;
   unsigned long hash;
   const XML_Char *uriName;
 } NS_ATT;
 
 typedef struct {
   const XML_Char *name;
   PREFIX *prefix;
   const ATTRIBUTE_ID *idAtt;
   int nDefaultAtts;
   int allocDefaultAtts;
   DEFAULT_ATTRIBUTE *defaultAtts;
 } ELEMENT_TYPE;
 
 typedef struct {
   HASH_TABLE generalEntities;
   HASH_TABLE elementTypes;
   HASH_TABLE attributeIds;
   HASH_TABLE prefixes;
   STRING_POOL pool;
   STRING_POOL entityValuePool;
   /* false once a parameter entity reference has been skipped */
   XML_Bool keepProcessing;
   /* true once an internal or external PE reference has been encountered;
      this includes the reference to an external subset */
   XML_Bool hasParamEntityRefs;
   XML_Bool standalone;
 #ifdef XML_DTD
   /* indicates if external PE has been read */
   XML_Bool paramEntityRead;
   HASH_TABLE paramEntities;
 #endif /* XML_DTD */
   PREFIX defaultPrefix;
   /* === scaffolding for building content model === */
   XML_Bool in_eldecl;
   CONTENT_SCAFFOLD *scaffold;
   unsigned contentStringLen;
   unsigned scaffSize;
   unsigned scaffCount;
   int scaffLevel;
   int *scaffIndex;
 } DTD;
 
 typedef struct open_internal_entity {
   const char *internalEventPtr;
   const char *internalEventEndPtr;
   struct open_internal_entity *next;
   ENTITY *entity;
   int startTagLevel;
   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;
 static Processor contentProcessor;
 static Processor cdataSectionProcessor;
 #ifdef XML_DTD
 static Processor ignoreSectionProcessor;
 static Processor externalParEntProcessor;
 static Processor externalParEntInitProcessor;
 static Processor entityValueProcessor;
 static Processor entityValueInitProcessor;
 #endif /* XML_DTD */
 static Processor epilogProcessor;
 static Processor errorProcessor;
 static Processor externalEntityInitProcessor;
 static Processor externalEntityInitProcessor2;
 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 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 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);
 
 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)
 #define poolLength(pool) ((pool)->ptr - (pool)->start)
 #define poolChop(pool) ((void)--(pool->ptr))
 #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
      macro works. */
   void *m_userData;
   void *m_handlerArg;
   char *m_buffer;
   const XML_Memory_Handling_Suite m_mem;
   /* first character to be parsed */
   const char *m_bufferPtr;
   /* past last character to be parsed */
   char *m_bufferEnd;
   /* allocated end of m_buffer */
   const char *m_bufferLim;
   XML_Index m_parseEndByteIndex;
   const char *m_parseEndPtr;
   XML_Char *m_dataBuf;
   XML_Char *m_dataBufEnd;
   XML_StartElementHandler m_startElementHandler;
   XML_EndElementHandler m_endElementHandler;
   XML_CharacterDataHandler m_characterDataHandler;
   XML_ProcessingInstructionHandler m_processingInstructionHandler;
   XML_CommentHandler m_commentHandler;
   XML_StartCdataSectionHandler m_startCdataSectionHandler;
   XML_EndCdataSectionHandler m_endCdataSectionHandler;
   XML_DefaultHandler m_defaultHandler;
   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
   XML_NotationDeclHandler m_notationDeclHandler;
   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
   XML_NotStandaloneHandler m_notStandaloneHandler;
   XML_ExternalEntityRefHandler m_externalEntityRefHandler;
   XML_Parser m_externalEntityRefHandlerArg;
   XML_SkippedEntityHandler m_skippedEntityHandler;
   XML_UnknownEncodingHandler m_unknownEncodingHandler;
   XML_ElementDeclHandler m_elementDeclHandler;
   XML_AttlistDeclHandler m_attlistDeclHandler;
   XML_EntityDeclHandler m_entityDeclHandler;
   XML_XmlDeclHandler m_xmlDeclHandler;
   const ENCODING *m_encoding;
   INIT_ENCODING m_initEncoding;
   const ENCODING *m_internalEncoding;
   const XML_Char *m_protocolEncodingName;
   XML_Bool m_ns;
   XML_Bool m_ns_triplets;
   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;
   const char *m_eventPtr;
   const char *m_eventEndPtr;
   const char *m_positionPtr;
   OPEN_INTERNAL_ENTITY *m_openInternalEntities;
   OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
   XML_Bool m_defaultExpandInternalEntities;
   int m_tagLevel;
   ENTITY *m_declEntity;
   const XML_Char *m_doctypeName;
   const XML_Char *m_doctypeSysid;
   const XML_Char *m_doctypePubid;
   const XML_Char *m_declAttributeType;
   const XML_Char *m_declNotationName;
   const XML_Char *m_declNotationPublicId;
   ELEMENT_TYPE *m_declElementType;
   ATTRIBUTE_ID *m_declAttributeId;
   XML_Bool m_declAttributeIsCdata;
   XML_Bool m_declAttributeIsId;
   DTD *m_dtd;
   const XML_Char *m_curBase;
   TAG *m_tagStack;
   TAG *m_freeTagList;
   BINDING *m_inheritedBindings;
   BINDING *m_freeBindingList;
   int m_attsSize;
   int m_nSpecifiedAtts;
   int m_idAttIndex;
   ATTRIBUTE *m_atts;
   NS_ATT *m_nsAtts;
   unsigned long m_nsAttsVersion;
   unsigned char m_nsAttsPower;
 #ifdef XML_ATTR_INFO
   XML_AttrInfo *m_attInfo;
 #endif
   POSITION m_position;
   STRING_POOL m_tempPool;
   STRING_POOL m_temp2Pool;
   char *m_groupConnector;
   unsigned int m_groupSize;
   XML_Char m_namespaceSeparator;
   XML_Parser m_parentParser;
   XML_ParsingStatus m_parsingStatus;
 #ifdef XML_DTD
   XML_Bool m_isParamEntity;
   XML_Bool m_useForeignDTD;
   enum XML_ParamEntityParsing m_paramEntityParsing;
 #endif
   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;
       if (bytesWrittenTotal >= count)
         success = 1;
     }
   } while (! success && (errno == EINTR));
 
   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);
   if (fd < 0) {
     return 0;
   }
 
   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);
 
     if (bytesWrittenMore > 0) {
       bytesWrittenTotal += bytesWrittenMore;
       if (bytesWrittenTotal >= count)
         success = 1;
     }
   } while (! success && (errno == EINTR));
 
   close(fd);
   return success;
 }
 
-#endif  /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
 
-#endif  /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
 
+#if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)
 
-#if defined(HAVE_ARC4RANDOM)
-
 static void
-writeRandomBytes_arc4random(void * target, size_t count) {
+writeRandomBytes_arc4random(void *target, size_t count) {
   size_t bytesWrittenTotal = 0;
 
   while (bytesWrittenTotal < count) {
     const uint32_t random32 = arc4random();
     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) */
+#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"));
+writeRandomBytes_rand_s(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
 
-  if (advapi32) {
-    const RTLGENRANDOM_FUNC RtlGenRandom
-        = (RTLGENRANDOM_FUNC)GetProcAddress(advapi32, "SystemFunction036");
-    if (RtlGenRandom) {
-      if (RtlGenRandom((PVOID)target, (ULONG)count) == TRUE) {
-        success = 1;
-      }
+  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;
 
   /* "Failproof" high quality providers: */
 #if defined(HAVE_ARC4RANDOM_BUF)
   arc4random_buf(&entropy, sizeof(entropy));
   return ENTROPY_DEBUG("arc4random_buf", entropy);
 #elif defined(HAVE_ARC4RANDOM)
   writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));
   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 */
   entropy = gather_time_entropy() ^ getpid();
 
   /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */
   if (sizeof(unsigned long) == 4) {
     return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
   } else {
     return ENTROPY_DEBUG("fallback(8)",
-        entropy * (unsigned long)2305843009213693951ULL);
+                         entropy * (unsigned long)2305843009213693951ULL);
   }
 #endif
 }
 
 static unsigned long
 get_hash_secret_salt(XML_Parser parser) {
   if (parser->m_parentParser != NULL)
     return get_hash_secret_salt(parser->m_parentParser);
   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) {
       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
       mtemp->malloc_fcn = malloc;
       mtemp->realloc_fcn = realloc;
       mtemp->free_fcn = free;
     }
   }
 
-  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
     FREE(parser, parser->m_attInfo);
 #endif
     FREE(parser, parser);
     return NULL;
   }
   parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
 
   if (dtd)
     parser->m_dtd = dtd;
   else {
     parser->m_dtd = dtdCreate(&parser->m_mem);
     if (parser->m_dtd == NULL) {
       FREE(parser, parser->m_dataBuf);
       FREE(parser, parser->m_atts);
 #ifdef XML_ATTR_INFO
       FREE(parser, parser->m_attInfo);
 #endif
       FREE(parser, parser);
       return NULL;
     }
   }
 
   parser->m_freeBindingList = NULL;
   parser->m_freeTagList = NULL;
   parser->m_freeInternalEntities = NULL;
 
   parser->m_groupSize = 0;
   parser->m_groupConnector = NULL;
 
   parser->m_unknownEncodingHandler = NULL;
   parser->m_unknownEncodingHandlerData = NULL;
 
   parser->m_namespaceSeparator = ASCII_EXCL;
   parser->m_ns = XML_FALSE;
   parser->m_ns_triplets = XML_FALSE;
 
   parser->m_nsAtts = NULL;
   parser->m_nsAttsVersion = 0;
   parser->m_nsAttsPower = 0;
 
   parser->m_protocolEncodingName = NULL;
 
   poolInit(&parser->m_tempPool, &(parser->m_mem));
   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;
   }
 
   if (nameSep) {
     parser->m_ns = XML_TRUE;
     parser->m_internalEncoding = XmlGetInternalEncodingNS();
     parser->m_namespaceSeparator = *nameSep;
-  }
-  else {
+  } else {
     parser->m_internalEncoding = XmlGetInternalEncoding();
   }
 
   return parser;
 }
 
 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) {
     parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
   }
   parser->m_curBase = NULL;
   XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
   parser->m_userData = NULL;
   parser->m_handlerArg = NULL;
   parser->m_startElementHandler = NULL;
   parser->m_endElementHandler = NULL;
   parser->m_characterDataHandler = NULL;
   parser->m_processingInstructionHandler = NULL;
   parser->m_commentHandler = NULL;
   parser->m_startCdataSectionHandler = NULL;
   parser->m_endCdataSectionHandler = NULL;
   parser->m_defaultHandler = NULL;
   parser->m_startDoctypeDeclHandler = NULL;
   parser->m_endDoctypeDeclHandler = NULL;
   parser->m_unparsedEntityDeclHandler = NULL;
   parser->m_notationDeclHandler = NULL;
   parser->m_startNamespaceDeclHandler = NULL;
   parser->m_endNamespaceDeclHandler = NULL;
   parser->m_notStandaloneHandler = NULL;
   parser->m_externalEntityRefHandler = NULL;
   parser->m_externalEntityRefHandlerArg = parser;
   parser->m_skippedEntityHandler = NULL;
   parser->m_elementDeclHandler = NULL;
   parser->m_attlistDeclHandler = NULL;
   parser->m_entityDeclHandler = NULL;
   parser->m_xmlDeclHandler = NULL;
   parser->m_bufferPtr = parser->m_buffer;
   parser->m_bufferEnd = parser->m_buffer;
   parser->m_parseEndByteIndex = 0;
   parser->m_parseEndPtr = NULL;
   parser->m_declElementType = NULL;
   parser->m_declAttributeId = NULL;
   parser->m_declEntity = NULL;
   parser->m_doctypeName = NULL;
   parser->m_doctypeSysid = NULL;
   parser->m_doctypePubid = NULL;
   parser->m_declAttributeType = NULL;
   parser->m_declNotationName = NULL;
   parser->m_declNotationPublicId = NULL;
   parser->m_declAttributeIsCdata = XML_FALSE;
   parser->m_declAttributeIsId = XML_FALSE;
   memset(&parser->m_position, 0, sizeof(POSITION));
   parser->m_errorCode = XML_ERROR_NONE;
   parser->m_eventPtr = NULL;
   parser->m_eventEndPtr = NULL;
   parser->m_positionPtr = NULL;
   parser->m_openInternalEntities = NULL;
   parser->m_defaultExpandInternalEntities = XML_TRUE;
   parser->m_tagLevel = 0;
   parser->m_tagStack = NULL;
   parser->m_inheritedBindings = NULL;
   parser->m_nSpecifiedAtts = 0;
   parser->m_unknownEncodingMem = NULL;
   parser->m_unknownEncodingRelease = NULL;
   parser->m_unknownEncodingData = NULL;
   parser->m_parentParser = NULL;
   parser->m_parsingStatus.parsing = XML_INITIALIZED;
 #ifdef XML_DTD
   parser->m_isParamEntity = XML_FALSE;
   parser->m_useForeignDTD = XML_FALSE;
   parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
 #endif
   parser->m_hash_secret_salt = 0;
 }
 
 /* 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;
     b->nextTagBinding = parser->m_freeBindingList;
     parser->m_freeBindingList = b;
   }
 }
 
 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;
   /* move m_tagStack to m_freeTagList */
   tStk = parser->m_tagStack;
   while (tStk) {
     TAG *tag = tStk;
     tStk = tStk->parent;
     tag->parent = parser->m_freeTagList;
     moveToFreeBindingList(parser, tag->bindings);
     tag->bindings = NULL;
     parser->m_freeTagList = tag;
   }
   /* move m_openInternalEntities to m_freeInternalEntities */
   openEntityList = parser->m_openInternalEntities;
   while (openEntityList) {
     OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
     openEntityList = openEntity->next;
     openEntity->next = parser->m_freeInternalEntities;
     parser->m_freeInternalEntities = openEntity;
   }
   moveToFreeBindingList(parser, parser->m_inheritedBindings);
   FREE(parser, parser->m_unknownEncodingMem);
   if (parser->m_unknownEncodingRelease)
     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
   poolClear(&parser->m_tempPool);
   poolClear(&parser->m_temp2Pool);
   FREE(parser, (void *)parser->m_protocolEncodingName);
   parser->m_protocolEncodingName = NULL;
   parserInit(parser, encodingName);
   dtdReset(parser->m_dtd, &parser->m_mem);
   return XML_TRUE;
 }
 
 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 */
   FREE(parser, (void *)parser->m_protocolEncodingName);
 
   if (encodingName == NULL)
     /* No new encoding name */
     parser->m_protocolEncodingName = NULL;
   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;
   XML_StartElementHandler oldStartElementHandler;
   XML_EndElementHandler oldEndElementHandler;
   XML_CharacterDataHandler oldCharacterDataHandler;
   XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
   XML_CommentHandler oldCommentHandler;
   XML_StartCdataSectionHandler oldStartCdataSectionHandler;
   XML_EndCdataSectionHandler oldEndCdataSectionHandler;
   XML_DefaultHandler oldDefaultHandler;
   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
   XML_NotationDeclHandler oldNotationDeclHandler;
   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
   XML_NotStandaloneHandler oldNotStandaloneHandler;
   XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
   XML_SkippedEntityHandler oldSkippedEntityHandler;
   XML_UnknownEncodingHandler oldUnknownEncodingHandler;
   XML_ElementDeclHandler oldElementDeclHandler;
   XML_AttlistDeclHandler oldAttlistDeclHandler;
   XML_EntityDeclHandler oldEntityDeclHandler;
   XML_XmlDeclHandler oldXmlDeclHandler;
-  ELEMENT_TYPE * oldDeclElementType;
+  ELEMENT_TYPE *oldDeclElementType;
 
   void *oldUserData;
   void *oldHandlerArg;
   XML_Bool oldDefaultExpandInternalEntities;
   XML_Parser oldExternalEntityRefHandlerArg;
 #ifdef XML_DTD
   enum XML_ParamEntityParsing oldParamEntityParsing;
   int oldInEntityValue;
 #endif
   XML_Bool oldns_triplets;
   /* Note that the new parser shares the same hash secret as the old
      parser, so that dtdCopy and copyEntityTable can lookup values
      from hash tables associated with either parser without us having
      to worry which hash secrets each table has.
   */
   unsigned long oldhash_secret_salt;
 
   /* Validate the oldParser parameter before we pull everything out of it */
   if (oldParser == NULL)
     return NULL;
 
   /* Stash the original parser contents on the stack */
   oldDtd = parser->m_dtd;
   oldStartElementHandler = parser->m_startElementHandler;
   oldEndElementHandler = parser->m_endElementHandler;
   oldCharacterDataHandler = parser->m_characterDataHandler;
   oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
   oldCommentHandler = parser->m_commentHandler;
   oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
   oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
   oldDefaultHandler = parser->m_defaultHandler;
   oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
   oldNotationDeclHandler = parser->m_notationDeclHandler;
   oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
   oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
   oldNotStandaloneHandler = parser->m_notStandaloneHandler;
   oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
   oldSkippedEntityHandler = parser->m_skippedEntityHandler;
   oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
   oldElementDeclHandler = parser->m_elementDeclHandler;
   oldAttlistDeclHandler = parser->m_attlistDeclHandler;
   oldEntityDeclHandler = parser->m_entityDeclHandler;
   oldXmlDeclHandler = parser->m_xmlDeclHandler;
   oldDeclElementType = parser->m_declElementType;
 
   oldUserData = parser->m_userData;
   oldHandlerArg = parser->m_handlerArg;
   oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
   oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
 #ifdef XML_DTD
   oldParamEntityParsing = parser->m_paramEntityParsing;
   oldInEntityValue = parser->m_prologState.inEntityValue;
 #endif
   oldns_triplets = parser->m_ns_triplets;
   /* Note that the new parser shares the same hash secret as the old
      parser, so that dtdCopy and copyEntityTable can lookup values
      from hash tables associated with either parser without us having
      to worry which hash secrets each table has.
   */
   oldhash_secret_salt = parser->m_hash_secret_salt;
 
 #ifdef XML_DTD
-  if (!context)
+  if (! context)
     newDtd = oldDtd;
 #endif /* XML_DTD */
 
   /* Note that the magical uses of the pre-processor to make field
      access look more like C++ require that `parser' be overwritten
      here.  This makes this function more painful to follow than it
      would be otherwise.
   */
   if (parser->m_ns) {
     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;
   parser->m_endElementHandler = oldEndElementHandler;
   parser->m_characterDataHandler = oldCharacterDataHandler;
   parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
   parser->m_commentHandler = oldCommentHandler;
   parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
   parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
   parser->m_defaultHandler = oldDefaultHandler;
   parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
   parser->m_notationDeclHandler = oldNotationDeclHandler;
   parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
   parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
   parser->m_notStandaloneHandler = oldNotStandaloneHandler;
   parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
   parser->m_skippedEntityHandler = oldSkippedEntityHandler;
   parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
   parser->m_elementDeclHandler = oldElementDeclHandler;
   parser->m_attlistDeclHandler = oldAttlistDeclHandler;
   parser->m_entityDeclHandler = oldEntityDeclHandler;
   parser->m_xmlDeclHandler = oldXmlDeclHandler;
   parser->m_declElementType = oldDeclElementType;
   parser->m_userData = oldUserData;
   if (oldUserData == oldHandlerArg)
     parser->m_handlerArg = parser->m_userData;
   else
     parser->m_handlerArg = parser;
   if (oldExternalEntityRefHandlerArg != oldParser)
     parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
   parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
   parser->m_ns_triplets = oldns_triplets;
   parser->m_hash_secret_salt = oldhash_secret_salt;
   parser->m_parentParser = oldParser;
 #ifdef XML_DTD
   parser->m_paramEntityParsing = oldParamEntityParsing;
   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);
     parser->m_processor = externalParEntInitProcessor;
   }
 #endif /* XML_DTD */
   return parser;
 }
 
 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);
     FREE(parser, b);
   }
 }
 
 void XMLCALL
-XML_ParserFree(XML_Parser parser)
-{
+XML_ParserFree(XML_Parser parser) {
   TAG *tagList;
   OPEN_INTERNAL_ENTITY *entityList;
   if (parser == NULL)
     return;
   /* free m_tagStack and m_freeTagList */
   tagList = parser->m_tagStack;
   for (;;) {
     TAG *p;
     if (tagList == NULL) {
       if (parser->m_freeTagList == NULL)
         break;
       tagList = parser->m_freeTagList;
       parser->m_freeTagList = NULL;
     }
     p = tagList;
     tagList = tagList->parent;
     FREE(parser, p->buf);
     destroyBindings(p->bindings, parser);
     FREE(parser, p);
   }
   /* free m_openInternalEntities and m_freeInternalEntities */
   entityList = parser->m_openInternalEntities;
   for (;;) {
     OPEN_INTERNAL_ENTITY *openEntity;
     if (entityList == NULL) {
       if (parser->m_freeInternalEntities == NULL)
         break;
       entityList = parser->m_freeInternalEntities;
       parser->m_freeInternalEntities = NULL;
     }
     openEntity = entityList;
     entityList = entityList->next;
     FREE(parser, openEntity);
   }
 
   destroyBindings(parser->m_freeBindingList, parser);
   destroyBindings(parser->m_inheritedBindings, parser);
   poolDestroy(&parser->m_tempPool);
   poolDestroy(&parser->m_temp2Pool);
   FREE(parser, (void *)parser->m_protocolEncodingName);
 #ifdef XML_DTD
   /* 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);
 #endif
   FREE(parser, parser->m_groupConnector);
   FREE(parser, parser->m_buffer);
   FREE(parser, parser->m_dataBuf);
   FREE(parser, parser->m_nsAtts);
   FREE(parser, parser->m_unknownEncodingMem);
   if (parser->m_unknownEncodingRelease)
     parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
   FREE(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;
 #else
   return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
 #endif
 }
 
 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)
     parser->m_handlerArg = parser->m_userData = p;
   else
     parser->m_userData = 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;
 }
 #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;
   parser->m_endElementHandler = end;
 }
 
 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;
 }
 
 void XMLCALL
 XML_SetCdataSectionHandler(XML_Parser parser,
                            XML_StartCdataSectionHandler start,
-                           XML_EndCdataSectionHandler end)
-{
+                           XML_EndCdataSectionHandler end) {
   if (parser == NULL)
     return;
   parser->m_startCdataSectionHandler = start;
   parser->m_endCdataSectionHandler = end;
 }
 
 void XMLCALL
 XML_SetStartCdataSectionHandler(XML_Parser parser,
                                 XML_StartCdataSectionHandler start) {
   if (parser != NULL)
     parser->m_startCdataSectionHandler = start;
 }
 
 void XMLCALL
 XML_SetEndCdataSectionHandler(XML_Parser parser,
                               XML_EndCdataSectionHandler end) {
   if (parser != NULL)
     parser->m_endCdataSectionHandler = end;
 }
 
 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;
   parser->m_defaultExpandInternalEntities = XML_FALSE;
 }
 
 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;
   parser->m_defaultExpandInternalEntities = XML_TRUE;
 }
 
 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;
   parser->m_endDoctypeDeclHandler = end;
 }
 
 void XMLCALL
 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
                                XML_StartDoctypeDeclHandler start) {
   if (parser != NULL)
     parser->m_startDoctypeDeclHandler = start;
 }
 
 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;
 }
 
 void XMLCALL
 XML_SetNamespaceDeclHandler(XML_Parser parser,
                             XML_StartNamespaceDeclHandler start,
-                            XML_EndNamespaceDeclHandler end)
-{
+                            XML_EndNamespaceDeclHandler end) {
   if (parser == NULL)
     return;
   parser->m_startNamespaceDeclHandler = start;
   parser->m_endNamespaceDeclHandler = end;
 }
 
 void XMLCALL
 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
                                  XML_StartNamespaceDeclHandler start) {
   if (parser != NULL)
     parser->m_startNamespaceDeclHandler = start;
 }
 
 void XMLCALL
 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
                                XML_EndNamespaceDeclHandler end) {
   if (parser != NULL)
     parser->m_endNamespaceDeclHandler = end;
 }
 
 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)
     parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
   else
     parser->m_externalEntityRefHandlerArg = parser;
 }
 
 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;
   parser->m_unknownEncodingHandlerData = data;
 }
 
 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;
   return 1;
 #else
   return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
 #endif
 }
 
 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;
     return XML_STATUS_ERROR;
   }
   switch (parser->m_parsingStatus.parsing) {
   case XML_SUSPENDED:
     parser->m_errorCode = XML_ERROR_SUSPENDED;
     return XML_STATUS_ERROR;
   case XML_FINISHED:
     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;
     }
     /* fall through */
   default:
     parser->m_parsingStatus.parsing = XML_PARSING;
   }
 
   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;
 
     /* If data are left over from last buffer, and we now know that these
        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) {
       case XML_SUSPENDED:
         /* It is hard to be certain, but it seems that this case
          * cannot occur.  This code is cleaning up a previous parse
          * with no new data (since len == 0).  Changing the parsing
          * state requires getting to execute a handler function, and
          * there doesn't seem to be an opportunity for that while in
          * this circumstance.
          *
          * Given the uncertainty, we retain the code but exclude it
          * from coverage tests.
          *
          * 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 */
       case XML_INITIALIZED:
       case XML_PARSING:
         parser->m_parsingStatus.parsing = XML_FINISHED;
         /* fall through */
       default:
         return XML_STATUS_OK;
       }
     }
     parser->m_eventEndPtr = parser->m_eventPtr;
     parser->m_processor = errorProcessor;
     return XML_STATUS_ERROR;
   }
 #ifndef XML_CONTEXT_BYTES
   else if (parser->m_bufferPtr == parser->m_bufferEnd) {
     const char *end;
     int nLeftOver;
     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;
         break;
       case XML_INITIALIZED:
       case XML_PARSING:
         if (isFinal) {
           parser->m_parsingStatus.parsing = XML_FINISHED;
           return XML_STATUS_OK;
         }
       /* fall through */
       default:
         result = XML_STATUS_OK;
       }
     }
 
-    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);
         if (bytesToAllocate > 0) {
           temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
         }
         if (temp == NULL) {
           parser->m_errorCode = XML_ERROR_NO_MEMORY;
           parser->m_eventPtr = parser->m_eventEndPtr = NULL;
           parser->m_processor = errorProcessor;
           return XML_STATUS_ERROR;
         }
         parser->m_buffer = temp;
         parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
       }
       memcpy(parser->m_buffer, end, nLeftOver);
     }
     parser->m_bufferPtr = parser->m_buffer;
     parser->m_bufferEnd = parser->m_buffer + nLeftOver;
     parser->m_positionPtr = parser->m_bufferPtr;
     parser->m_parseEndPtr = parser->m_bufferEnd;
     parser->m_eventPtr = parser->m_bufferPtr;
     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)
       return XML_STATUS_ERROR;
     else {
       memcpy(buff, s, len);
       return XML_ParseBuffer(parser, len, 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;
 
   if (parser == NULL)
     return XML_STATUS_ERROR;
   switch (parser->m_parsingStatus.parsing) {
   case XML_SUSPENDED:
     parser->m_errorCode = XML_ERROR_SUSPENDED;
     return XML_STATUS_ERROR;
   case XML_FINISHED:
     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;
     }
     /* fall through */
   default:
     parser->m_parsingStatus.parsing = XML_PARSING;
   }
 
   start = parser->m_bufferPtr;
   parser->m_positionPtr = start;
   parser->m_bufferEnd += len;
   parser->m_parseEndPtr = parser->m_bufferEnd;
   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;
       break;
     case XML_INITIALIZED:
     case XML_PARSING:
       if (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) {
     parser->m_errorCode = XML_ERROR_NO_MEMORY;
     return NULL;
   }
   switch (parser->m_parsingStatus.parsing) {
   case XML_SUSPENDED:
     parser->m_errorCode = XML_ERROR_SUSPENDED;
     return NULL;
   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;
     }
 #ifdef XML_CONTEXT_BYTES
     keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
     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;
       }
 #else
       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;
         return NULL;
       }
       newBuf = (char *)MALLOC(parser, bufferSize);
       if (newBuf == 0) {
         parser->m_errorCode = XML_ERROR_NO_MEMORY;
         return NULL;
       }
       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;
       }
 #else
       if (parser->m_bufferPtr) {
         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;
   }
   return parser->m_bufferEnd;
 }
 
 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) {
   case XML_SUSPENDED:
     if (resumable) {
       parser->m_errorCode = XML_ERROR_SUSPENDED;
       return XML_STATUS_ERROR;
     }
     parser->m_parsingStatus.parsing = XML_FINISHED;
     break;
   case XML_FINISHED:
     parser->m_errorCode = XML_ERROR_FINISHED;
     return XML_STATUS_ERROR;
   default:
     if (resumable) {
 #ifdef XML_DTD
       if (parser->m_isParamEntity) {
         parser->m_errorCode = XML_ERROR_SUSPEND_PE;
         return XML_STATUS_ERROR;
       }
 #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)
     return XML_STATUS_ERROR;
   if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
     parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
     return XML_STATUS_ERROR;
   }
   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;
       break;
     case XML_INITIALIZED:
     case XML_PARSING:
       if (parser->m_parsingStatus.finalBuffer) {
         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);
   *status = parser->m_parsingStatus;
 }
 
 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)
     return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
   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;
   if (parser->m_eventPtr && parser->m_buffer) {
     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
   (void)parser;
   (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;
   case XML_ERROR_NO_MEMORY:
     return XML_L("out of memory");
   case XML_ERROR_SYNTAX:
     return XML_L("syntax error");
   case XML_ERROR_NO_ELEMENTS:
     return XML_L("no element found");
   case XML_ERROR_INVALID_TOKEN:
     return XML_L("not well-formed (invalid token)");
   case XML_ERROR_UNCLOSED_TOKEN:
     return XML_L("unclosed token");
   case XML_ERROR_PARTIAL_CHAR:
     return XML_L("partial character");
   case XML_ERROR_TAG_MISMATCH:
     return XML_L("mismatched tag");
   case XML_ERROR_DUPLICATE_ATTRIBUTE:
     return XML_L("duplicate attribute");
   case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
     return XML_L("junk after document element");
   case XML_ERROR_PARAM_ENTITY_REF:
     return XML_L("illegal parameter entity reference");
   case XML_ERROR_UNDEFINED_ENTITY:
     return XML_L("undefined entity");
   case XML_ERROR_RECURSIVE_ENTITY_REF:
     return XML_L("recursive entity reference");
   case XML_ERROR_ASYNC_ENTITY:
     return XML_L("asynchronous entity");
   case XML_ERROR_BAD_CHAR_REF:
     return XML_L("reference to invalid character number");
   case XML_ERROR_BINARY_ENTITY_REF:
     return XML_L("reference to binary entity");
   case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
     return XML_L("reference to external entity in attribute");
   case XML_ERROR_MISPLACED_XML_PI:
     return XML_L("XML or text declaration not at start of entity");
   case XML_ERROR_UNKNOWN_ENCODING:
     return XML_L("unknown encoding");
   case XML_ERROR_INCORRECT_ENCODING:
     return XML_L("encoding specified in XML declaration is incorrect");
   case XML_ERROR_UNCLOSED_CDATA_SECTION:
     return XML_L("unclosed CDATA section");
   case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
     return XML_L("error in processing external entity reference");
   case XML_ERROR_NOT_STANDALONE:
     return XML_L("document is not standalone");
   case XML_ERROR_UNEXPECTED_STATE:
     return XML_L("unexpected parser state - please send a bug report");
   case XML_ERROR_ENTITY_DECLARED_IN_PE:
     return XML_L("entity declared in parameter entity");
   case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
     return XML_L("requested feature requires XML_DTD support in Expat");
   case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
     return XML_L("cannot change setting once parsing has begun");
   /* Added in 1.95.7. */
   case XML_ERROR_UNBOUND_PREFIX:
     return XML_L("unbound prefix");
   /* Added in 1.95.8. */
   case XML_ERROR_UNDECLARING_PREFIX:
     return XML_L("must not undeclare prefix");
   case XML_ERROR_INCOMPLETE_PE:
     return XML_L("incomplete markup in parameter entity");
   case XML_ERROR_XML_DECL:
     return XML_L("XML declaration not well-formed");
   case XML_ERROR_TEXT_DECL:
     return XML_L("text declaration not well-formed");
   case XML_ERROR_PUBLICID:
     return XML_L("illegal character(s) in public id");
   case XML_ERROR_SUSPENDED:
     return XML_L("parser suspended");
   case XML_ERROR_NOT_SUSPENDED:
     return XML_L("parser not suspended");
   case XML_ERROR_ABORTED:
     return XML_L("parsing aborted");
   case XML_ERROR_FINISHED:
     return XML_L("parsing finished");
   case XML_ERROR_SUSPEND_PE:
     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
      a macro, then rescan for more expansions. Thus, we use V2 to expand
      the version macros, then CPP will expand the resulting V1() macro
      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);
 
 #undef V1
 #undef V2
 }
 
 XML_Expat_Version XMLCALL
-XML_ExpatVersionInfo(void)
-{
+XML_ExpatVersionInfo(void) {
   XML_Expat_Version version;
 
   version.major = XML_MAJOR_VERSION;
   version.minor = XML_MINOR_VERSION;
   version.micro = XML_MICRO_VERSION;
 
   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;
 }
 
 /* Initially tag->rawName always points into the parse buffer;
    for those TAG instances opened while the current parse buffer was
    processed, and not yet closed, we need to store tag->rawName in a more
    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;
     int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
     char *rawNameBuf = tag->buf + nameLen;
     /* Stop if already stored.  Since m_tagStack is a stack, we can stop
        at the first entry that has already been copied; everything
        below it in the stack is already been accounted for in a
        previous call to this function.
     */
     if (tag->rawName == rawNameBuf)
       break;
     /* For re-use purposes we need to ensure that the
        size of tag->buf is a multiple of sizeof(XML_Char).
     */
     bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
     if (bufSize > tag->bufEnd - tag->buf) {
       char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
       if (temp == NULL)
         return XML_FALSE;
       /* if tag->name.str points to tag->buf (only when namespace
          processing is off) then we have to update it
       */
       if (tag->name.str == (XML_Char *)tag->buf)
         tag->name.str = (XML_Char *)temp;
       /* if tag->name.localPart is set (when namespace processing is on)
          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;
     }
     memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
     tag->rawName = rawNameBuf;
     tag = tag->parent;
   }
   return XML_TRUE;
 }
 
 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;
   parser->m_processor = externalEntityInitProcessor2;
   return externalEntityInitProcessor2(parser, start, end, endPtr);
 }
 
 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) {
   case XML_TOK_BOM:
     /* If we are at the end of the buffer, this would cause the next stage,
        i.e. externalEntityInitProcessor3, to pass control directly to
        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;
     }
     parser->m_eventPtr = start;
     return XML_ERROR_PARTIAL_CHAR;
   }
   parser->m_processor = externalEntityInitProcessor3;
   return externalEntityInitProcessor3(parser, start, end, endPtr);
 }
 
 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;
   tok = XmlContentTok(parser->m_encoding, start, end, &next);
   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;
     }
     return XML_ERROR_PARTIAL_CHAR;
   }
   parser->m_processor = externalEntityContentProcessor;
   parser->m_tagLevel = 1;
   return externalEntityContentProcessor(parser, start, end, endPtr);
 }
 
 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);
   }
   *eventPP = s;
 
   for (;;) {
     const char *next = s; /* XmlContentTok doesn't always set the last arg */
     int tok = XmlContentTok(enc, s, end, &next);
     *eventEndPP = next;
     switch (tok) {
     case XML_TOK_TRAILING_CR:
       if (haveMore) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       *eventEndPP = end;
       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?
       */
       if (startTagLevel == 0)
         return XML_ERROR_NO_ELEMENTS;
       if (parser->m_tagLevel != startTagLevel)
         return XML_ERROR_ASYNC_ENTITY;
       *nextPtr = end;
       return XML_ERROR_NONE;
     case XML_TOK_NONE:
       if (haveMore) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       if (startTagLevel > 0) {
         if (parser->m_tagLevel != startTagLevel)
           return XML_ERROR_ASYNC_ENTITY;
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       return XML_ERROR_NO_ELEMENTS;
     case XML_TOK_INVALID:
       *eventPP = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
       if (haveMore) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       return XML_ERROR_UNCLOSED_TOKEN;
     case XML_TOK_PARTIAL_CHAR:
       if (haveMore) {
         *nextPtr = s;
         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;
       }
-      if ((parser->m_tagLevel == 0) && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+      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);
+      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
           return epilogProcessor(parser, next, end, nextPtr);
       }
       break;
     case XML_TOK_END_TAG:
       if (parser->m_tagLevel == startTagLevel)
         return XML_ERROR_ASYNC_ENTITY;
       else {
         int len;
         const char *rawName;
         TAG *tag = parser->m_tagStack;
         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) {
           *eventPP = rawName;
           return XML_ERROR_TAG_MISMATCH;
         }
         --parser->m_tagLevel;
         if (parser->m_endElementHandler) {
           const XML_Char *localPart;
           const XML_Char *prefix;
           XML_Char *uri;
           localPart = tag->name.localPart;
           if (parser->m_ns && localPart) {
             /* localPart and prefix may have been overwritten in
                tag->name.str, since this points to the binding->uri
                buffer which gets re-used; so we have to add them again
             */
             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).
+    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 (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;
-        }
+         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;
         return XML_ERROR_NONE;
       }
       if (parser->m_characterDataHandler) {
         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?
       */
       if (startTagLevel == 0) {
         *eventPP = end;
         return XML_ERROR_NO_ELEMENTS;
       }
       if (parser->m_tagLevel != startTagLevel) {
         *eventPP = end;
         return XML_ERROR_ASYNC_ENTITY;
       }
       *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:
       /* All of the tokens produced by XmlContentTok() have their own
        * explicit cases, so this default is not strictly necessary.
        * However it is a useful safety net, so we retain the code and
        * simply exclude it from the coverage tests.
        *
        * LCOV_EXCL_START
        */
       if (parser->m_defaultHandler)
         reportDefault(parser, enc, s, next);
       break;
       /* LCOV_EXCL_STOP */
     }
     *eventPP = s = next;
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
-    default: ;
+    default:;
     }
   }
   /* not reached */
 }
 
 /* This function does not call free() on the allocated memory, merely
  * moving it to the parser's m_freeBindingList where it can be freed or
  * reused as appropriate.
  */
 static void
-freeBindings(XML_Parser parser, BINDING *bindings)
-{
+freeBindings(XML_Parser parser, BINDING *bindings) {
   while (bindings) {
     BINDING *b = bindings;
 
     /* m_startNamespaceDeclHandler will have been called for this
      * 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;
     parser->m_freeBindingList = b;
     b->prefix->binding = b->prevPrefixBinding;
   }
 }
 
 /* Precondition: all arguments must be non-NULL;
    Purpose:
    - normalize attributes
    - check attributes for well-formedness
    - generate namespace aware attribute names (URI, prefix)
    - build list of attributes for startElementHandler
    - default attributes
    - process namespace declarations (check and report them)
    - 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;
   int n;
   XML_Char *uri;
   int nPrefixes = 0;
   BINDING *binding;
   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;
 
   /* get the attributes from the tokenizer */
   n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
   if (n + nDefaultAtts > parser->m_attsSize) {
     int oldAttsSize = parser->m_attsSize;
     ATTRIBUTE *temp;
 #ifdef XML_ATTR_INFO
     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;
     }
     parser->m_attInfo = temp2;
 #endif
     if (n > oldAttsSize)
       XmlGetAttributes(enc, attStr, n, parser->m_atts);
   }
 
   appAtts = (const XML_Char **)parser->m_atts;
   for (i = 0; i < n; i++) {
     ATTRIBUTE *currAtt = &parser->m_atts[i];
 #ifdef XML_ATTR_INFO
     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
        namespace are used. For this case we have a check further down.
     */
     if ((attId->name)[-1]) {
       if (enc == parser->m_encoding)
         parser->m_eventPtr = parser->m_atts[i].name;
       return XML_ERROR_DUPLICATE_ATTRIBUTE;
     }
     (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;
 
       /* figure out whether declared as other than CDATA */
       if (attId->maybeTokenized) {
         int j;
         for (j = 0; j < nDefaultAtts; j++) {
           if (attId == elementType->defaultAtts[j].id) {
             isCdata = elementType->defaultAtts[j].isCdata;
             break;
           }
         }
       }
 
       /* 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;
       poolFinish(&parser->m_tempPool);
     }
     /* handle prefixed attribute names */
     if (attId->prefix) {
       if (attId->xmlns) {
         /* deal with namespace declarations here */
         enum XML_Error result = addBinding(parser, attId->prefix, attId,
                                            appAtts[attIndex], bindingsPtr);
         if (result)
           return result;
         --attIndex;
-      }
-      else {
+      } else {
         /* deal with other prefixed names later */
         attIndex++;
         nPrefixes++;
         (attId->name)[-1] = 2;
       }
-    }
-    else
+    } else
       attIndex++;
   }
 
   /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
   parser->m_nSpecifiedAtts = attIndex;
   if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
     for (i = 0; i < attIndex; i += 2)
       if (appAtts[i] == elementType->idAtt->name) {
         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;
       }
     }
   }
   appAtts[attIndex] = 0;
 
   /* expand prefixed attribute names, check for duplicates,
      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;
 
     /* 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;
         struct siphash sip_state;
         struct sipkey sip_key;
 
         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
            * has to have passed through the hash table lookup once
            * already.  That implies that an entry for it already
            * exists, so the lookup above will return a pointer to
            * already allocated memory.  There is no opportunaity for
            * the allocator to fail, so the condition above cannot be
            * fulfilled.
            *
            * Since it is difficult to be certain that the above
            * analysis is complete, we retain the test and merely
            * remove the code from coverage tests.
            */
           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;
         }
 
         sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
 
         while (*s++ != XML_T(ASCII_COLON))
           ;
 
         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++);
 
         uriHash = (unsigned long)sip24_final(&sip_state);
 
         { /* Check hash table for duplicate of expanded name (uriName).
              Derived from code in lookup(parser, HASH_TABLE *table, ...).
           */
           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++);
         }
 
         /* store expanded name in attribute list */
         s = poolStart(&parser->m_tempPool);
         poolFinish(&parser->m_tempPool);
         appAtts[i] = s;
 
         /* fill empty slot with new version, uriName and hash value */
         parser->m_nsAtts[j].version = version;
         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 */
   for (; i < attIndex; i += 2)
     ((XML_Char *)(appAtts[i]))[-1] = 0;
   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));
     for (p = parser->m_tagStack; p; p = p->parent)
       if (p->name.str == binding->uri)
         p->name.str = uri;
     FREE(parser, binding->uri);
     binding->uri = uri;
   }
   /* if m_namespaceSeparator != '\0' then uri includes it already */
   uri = binding->uri + binding->uriLen;
   memcpy(uri, localPart, i * sizeof(XML_Char));
   /* 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;
   return XML_ERROR_NONE;
 }
 
 /* addBinding() overwrites the value of prefix->binding without checking.
    Therefore one must keep track of the old value outside of addBinding().
 */
 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;
   XML_Bool isXMLNS = XML_TRUE;
 
   BINDING *b;
   int len;
 
   /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
   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;
 
     if (prefix->name[3] == XML_T('\0'))
       mustBeXML = XML_TRUE;
   }
 
   for (len = 0; uri[len]; len++) {
     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;
   }
   isXML = isXML && len == xmlLen;
   isXMLNS = isXMLNS && len == xmlnsLen;
 
   if (mustBeXML != isXML)
     return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
                      : XML_ERROR_RESERVED_NAMESPACE_URI;
 
   if (isXMLNS)
     return XML_ERROR_RESERVED_NAMESPACE_URI;
 
   if (parser->m_namespaceSeparator)
     len++;
   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;
     }
     b->uriAlloc = len + EXPAND_SPARE;
   }
   b->uriLen = len;
   memcpy(b->uri, uri, len * sizeof(XML_Char));
   if (parser->m_namespaceSeparator)
     b->uri[len - 1] = parser->m_namespaceSeparator;
   b->prefix = prefix;
   b->attId = attId;
   b->prevPrefixBinding = prefix->binding;
   /* NULL binding when default namespace undeclared */
   if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
     prefix->binding = NULL;
   else
     prefix->binding = b;
   b->nextTagBinding = *bindingsPtr;
   *bindingsPtr = b;
   /* 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;
 }
 
 /* The idea here is to avoid using stack for each CDATA section when
    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);
     }
   }
   return result;
 }
 
 /* startPtr gets set to non-null if the section is closed, and to null if
    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;
   if (enc == parser->m_encoding) {
     eventPP = &parser->m_eventPtr;
     *eventPP = s;
     eventEndPP = &parser->m_eventEndPtr;
-  }
-  else {
+  } else {
     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
   }
   *eventPP = s;
   *startPtr = NULL;
 
   for (;;) {
     const char *next;
     int tok = XmlCdataSectionTok(enc, s, end, &next);
     *eventEndPP = next;
     switch (tok) {
     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;
       *nextPtr = next;
       if (parser->m_parsingStatus.parsing == XML_FINISHED)
         return XML_ERROR_ABORTED;
       else
         return XML_ERROR_NONE;
     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_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;
     case XML_TOK_PARTIAL_CHAR:
       if (haveMore) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       return XML_ERROR_PARTIAL_CHAR;
     case XML_TOK_PARTIAL:
     case XML_TOK_NONE:
       if (haveMore) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       return XML_ERROR_UNCLOSED_CDATA_SECTION;
     default:
       /* Every token returned by XmlCdataSectionTok() has its own
        * explicit case, so this default case will never be executed.
        * We retain it as a safety net and exclude it from the coverage
        * statistics.
        *
        * LCOV_EXCL_START
-      */
+       */
       *eventPP = next;
       return XML_ERROR_UNEXPECTED_STATE;
       /* LCOV_EXCL_STOP */
     }
 
     *eventPP = s = next;
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
-    default: ;
+    default:;
     }
   }
   /* not reached */
 }
 
 #ifdef XML_DTD
 
 /* The idea here is to avoid using stack for each IGNORE section when
    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) {
     parser->m_processor = prologProcessor;
     return prologProcessor(parser, start, end, endPtr);
   }
   return result;
 }
 
 /* startPtr gets set to non-null is the section is closed, and to null
    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;
   const char **eventPP;
   const char **eventEndPP;
   if (enc == parser->m_encoding) {
     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
      * from the internal entity processing, and IGNORE sections are an
      * error in internal entities.
      *
      * Since it really isn't clear that this is true, we keep the code
      * and just remove it from our coverage tests.
      *
      * LCOV_EXCL_START
      */
     eventPP = &(parser->m_openInternalEntities->internalEventPtr);
     eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
     /* LCOV_EXCL_STOP */
   }
   *eventPP = s;
   *startPtr = NULL;
   tok = XmlIgnoreSectionTok(enc, s, end, &next);
   *eventEndPP = next;
   switch (tok) {
   case XML_TOK_IGNORE_SECT:
     if (parser->m_defaultHandler)
       reportDefault(parser, enc, s, next);
     *startPtr = next;
     *nextPtr = next;
     if (parser->m_parsingStatus.parsing == XML_FINISHED)
       return XML_ERROR_ABORTED;
     else
       return XML_ERROR_NONE;
   case XML_TOK_INVALID:
     *eventPP = next;
     return XML_ERROR_INVALID_TOKEN;
   case XML_TOK_PARTIAL_CHAR:
     if (haveMore) {
       *nextPtr = s;
       return XML_ERROR_NONE;
     }
     return XML_ERROR_PARTIAL_CHAR;
   case XML_TOK_PARTIAL:
   case XML_TOK_NONE:
     if (haveMore) {
       *nextPtr = s;
       return XML_ERROR_NONE;
     }
     return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
   default:
     /* All of the tokens that XmlIgnoreSectionTok() returns have
      * explicit cases to handle them, so this default case is never
      * executed.  We keep it as a safety net anyway, and remove it
      * from our test coverage statistics.
      *
      * LCOV_EXCL_START
      */
     *eventPP = next;
     return XML_ERROR_UNEXPECTED_STATE;
     /* LCOV_EXCL_STOP */
   }
   /* not reached */
 }
 
 #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;
     for (i = 0; parser->m_protocolEncodingName[i]; i++) {
       if (i == sizeof(encodingBuf) - 1
           || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
         encodingBuf[0] = '\0';
         break;
       }
       encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
     }
     encodingBuf[i] = '\0';
     s = encodingBuf;
   }
 #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;
   const char *version = NULL;
   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) {
       /* Check that the specified encoding does not conflict with what
        * the parser has already deduced.  Do we have the same number
        * of bytes in the smallest representation of a character?  If
        * 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);
       poolClear(&parser->m_temp2Pool);
       if (result == XML_ERROR_UNKNOWN_ENCODING)
         parser->m_eventPtr = encodingName;
       return result;
     }
   }
 
   if (storedEncName || storedversion)
     poolClear(&parser->m_temp2Pool);
 
   return XML_ERROR_NONE;
 }
 
 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;
     for (i = 0; i < 256; i++)
       info.map[i] = -1;
     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;
         parser->m_encoding = enc;
         return XML_ERROR_NONE;
       }
     }
     if (info.release != NULL)
       info.release(info.data);
   }
   return XML_ERROR_UNKNOWN_ENCODING;
 }
 
 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;
   parser->m_processor = prologProcessor;
   return prologProcessor(parser, s, end, nextPtr);
 }
 
 #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;
 
   /* we know now that XML_Parse(Buffer) has been called,
      so we consider the external parameter entity read */
   parser->m_dtd->paramEntityRead = XML_TRUE;
 
   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;
   parser->m_eventPtr = start;
 
   for (;;) {
     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;
       }
       switch (tok) {
       case XML_TOK_INVALID:
         return XML_ERROR_INVALID_TOKEN;
       case XML_TOK_PARTIAL:
         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;
       *nextPtr = next;
       /* stop scanning for text declaration - we found one */
       parser->m_processor = entityValueProcessor;
       return entityValueProcessor(parser, next, end, nextPtr);
     }
     /* If we are at the end of the buffer, this would cause XmlPrologTok to
        return XML_TOK_NONE on the next call, which would then cause the
        function to exit with *nextPtr set to s - that is what we want for other
        tokens, but not for the BOM - we would rather like to skip it;
        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;
     }
     /* If we get this token, we have the start of what might be a
        normal tag, but not a declaration (i.e. it doesn't begin with
        "<!").  In a DTD context, that isn't legal.
     */
     else if (tok == XML_TOK_INSTANCE_START) {
       *nextPtr = next;
       return XML_ERROR_SYNTAX;
     }
     start = next;
     parser->m_eventPtr = start;
   }
 }
 
 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;
     }
     switch (tok) {
     case XML_TOK_INVALID:
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
       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;
     }
   }
   /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
      However, when parsing an external subset, doProlog will not accept a BOM
      as valid, and report a syntax error, so we have to skip the BOM
   */
   else if (tok == XML_TOK_BOM) {
     s = next;
     tok = XmlPrologTok(parser->m_encoding, s, end, &next);
   }
 
   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;
   int tok;
 
   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;
       }
       switch (tok) {
       case XML_TOK_INVALID:
         return XML_ERROR_INVALID_TOKEN;
       case XML_TOK_PARTIAL:
         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, enc, s, end);
     }
     start = next;
   }
 }
 
 #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;
   enum XML_Content_Quant quant;
 
   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);
   }
 
   for (;;) {
     int role;
     XML_Bool handleDefault = XML_TRUE;
     *eventPP = s;
     *eventEndPP = next;
     if (tok <= 0) {
       if (haveMore && tok != XML_TOK_INVALID) {
         *nextPtr = s;
         return XML_ERROR_NONE;
       }
       switch (tok) {
       case XML_TOK_INVALID:
         *eventPP = next;
         return XML_ERROR_INVALID_TOKEN;
       case XML_TOK_PARTIAL:
         return XML_ERROR_UNCLOSED_TOKEN;
       case XML_TOK_PARTIAL_CHAR:
         return XML_ERROR_PARTIAL_CHAR;
       case -XML_TOK_PROLOG_S:
         tok = -tok;
         break;
       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;
         }
         /* WFC: PE Between Declarations - must check that PE contains
            complete markup, not only for external PEs, but also for
            internal PEs if the reference occurs between declarations.
         */
         if (parser->m_isParamEntity || enc != parser->m_encoding) {
           if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
               == XML_ROLE_ERROR)
             return XML_ERROR_INCOMPLETE_PE;
           *nextPtr = s;
           return XML_ERROR_NONE;
         }
 #endif /* XML_DTD */
         return XML_ERROR_NO_ELEMENTS;
       default:
         tok = -tok;
         next = end;
         break;
       }
     }
     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;
         handleDefault = XML_FALSE;
       }
       parser->m_doctypeSysid = NULL; /* always initialize to NULL */
       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);
         parser->m_doctypePubid = pubId;
         handleDefault = XML_FALSE;
         goto alreadyChecked;
       }
       /* 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;
         poolFinish(&dtd->pool);
         /* Don't suppress the default handler if we fell through from
          * the XML_ROLE_DOCTYPE_PUBLIC_ID case.
          */
         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
           handleDefault = XML_FALSE;
       }
       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;
       }
       /* parser->m_doctypeSysid will be non-NULL in the case of a previous
          XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
          was not set, indicating an external subset
       */
 #ifdef XML_DTD
       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
              * and lookup() cannot fail.
              */
             return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
           }
           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 */
         }
         parser->m_useForeignDTD = XML_FALSE;
       }
 #endif /* XML_DTD */
       if (parser->m_endDoctypeDeclHandler) {
         parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
         handleDefault = XML_FALSE;
       }
       break;
     case XML_ROLE_INSTANCE_START:
 #ifdef XML_DTD
       /* if there is no DOCTYPE declaration then now is the
          last chance to read the foreign DTD
       */
       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
              is no external subset and we must reset dtd->hasParamEntityRefs
           */
           else
             dtd->hasParamEntityRefs = hadParamEntityRefs;
           /* end of DTD - no need to update dtd->keepProcessing */
         }
       }
 #endif /* XML_DTD */
       parser->m_processor = contentProcessor;
       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;
       parser->m_declAttributeIsId = XML_FALSE;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
       parser->m_declAttributeIsCdata = XML_TRUE;
       parser->m_declAttributeType = atypeCDATA;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_ID:
       parser->m_declAttributeIsId = XML_TRUE;
       parser->m_declAttributeType = atypeID;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
       parser->m_declAttributeType = atypeIDREF;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
       parser->m_declAttributeType = atypeIDREFS;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
       parser->m_declAttributeType = atypeENTITY;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
       parser->m_declAttributeType = atypeENTITIES;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
       parser->m_declAttributeType = atypeNMTOKEN;
       goto checkAttListDeclHandler;
     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
       parser->m_declAttributeType = atypeNMTOKENS;
     checkAttListDeclHandler:
       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
     case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
       if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
         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;
       }
       break;
     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;
         }
       }
       break;
     case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
     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;
         }
       }
       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;
       }
       break;
     case XML_ROLE_DOCTYPE_SYSTEM_ID:
 #ifdef XML_DTD
       parser->m_useForeignDTD = XML_FALSE;
 #endif /* XML_DTD */
       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);
         handleDefault = XML_FALSE;
       }
 #ifdef XML_DTD
       else
         /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
            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;
       }
 #endif /* XML_DTD */
       /* 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);
         /* Don't suppress the default handler if we fell through from
          * the XML_ROLE_DOCTYPE_SYSTEM_ID case.
          */
         if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
           handleDefault = XML_FALSE;
       }
       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;
     case XML_ROLE_NOTATION_NAME:
       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;
         poolFinish(&parser->m_tempPool);
         handleDefault = XML_FALSE;
       }
       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);
       break;
     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);
       break;
     case XML_ROLE_ERROR:
       switch (tok) {
       case XML_TOK_PARAM_ENTITY_REF:
         /* PE references in internal subset are
            not allowed within declarations. */
         return XML_ERROR_PARAM_ENTITY_REF;
       case XML_TOK_XML_DECL:
         return XML_ERROR_MISPLACED_XML_PI;
       default:
         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;
           }
         }
       }
       parser->m_groupConnector[parser->m_prologState.level] = 0;
       if (dtd->in_eldecl) {
         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;
         if (parser->m_elementDeclHandler)
           handleDefault = XML_FALSE;
       }
       break;
     case XML_ROLE_GROUP_SEQUENCE:
       if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
         return XML_ERROR_SYNTAX;
       parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
       if (dtd->in_eldecl && parser->m_elementDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_GROUP_CHOICE:
       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)
           handleDefault = XML_FALSE;
       }
       parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
       break;
     case XML_ROLE_PARAM_ENTITY_REF:
 #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);
         /* 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 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:
              *
              * If 'standalone' is false, the DTD must have no
              * parameter entities or we wouldn't have passed the outer
              * 'if' statement.  That measn the only entity in the hash
              * table is the external subset name "#" which cannot be
              * given as a parameter entity name in XML syntax, so the
              * lookup must have returned NULL and we don't even reach
              * the test for an internal entity.
              *
              * If 'standalone' is true, it does not seem to be
              * possible to create entities taking this code path that
              * are not internal entities, so fail the test above.
              *
              * Because this analysis is very uncertain, the code is
              * being left in place and merely removed from the
              * coverage test statistics.
              */
             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;
           }
           break;
         }
         if (entity->open)
           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;
           handleDefault = XML_FALSE;
           break;
         }
         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;
         dtd->in_eldecl = XML_TRUE;
         handleDefault = XML_FALSE;
       }
       break;
 
     case XML_ROLE_CONTENT_ANY:
     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;
       }
       break;
 
     case XML_ROLE_CONTENT_PCDATA:
       if (dtd->in_eldecl) {
         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
             = XML_CTYPE_MIXED;
         if (parser->m_elementDeclHandler)
           handleDefault = XML_FALSE;
       }
       break;
 
     case XML_ROLE_CONTENT_ELEMENT:
       quant = XML_CQUANT_NONE;
       goto elementContent;
     case XML_ROLE_CONTENT_ELEMENT_OPT:
       quant = XML_CQUANT_OPT;
       goto elementContent;
     case XML_ROLE_CONTENT_ELEMENT_REP:
       quant = XML_CQUANT_REP;
       goto elementContent;
     case XML_ROLE_CONTENT_ELEMENT_PLUS:
       quant = XML_CQUANT_PLUS;
     elementContent:
       if (dtd->in_eldecl) {
         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;
       }
       break;
 
     case XML_ROLE_GROUP_CLOSE:
       quant = XML_CQUANT_NONE;
       goto closeGroup;
     case XML_ROLE_GROUP_CLOSE_OPT:
       quant = XML_CQUANT_OPT;
       goto closeGroup;
     case XML_ROLE_GROUP_CLOSE_REP:
       quant = XML_CQUANT_REP;
       goto closeGroup;
     case XML_ROLE_GROUP_CLOSE_PLUS:
       quant = XML_CQUANT_PLUS;
     closeGroup:
       if (dtd->in_eldecl) {
         if (parser->m_elementDeclHandler)
           handleDefault = XML_FALSE;
         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;
         }
       }
       break;
       /* 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;
     case XML_ROLE_NONE:
       switch (tok) {
       case XML_TOK_BOM:
         handleDefault = XML_FALSE;
         break;
       }
       break;
     case XML_ROLE_DOCTYPE_NONE:
       if (parser->m_startDoctypeDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_ENTITY_NONE:
       if (dtd->keepProcessing && parser->m_entityDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_NOTATION_NONE:
       if (parser->m_notationDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_ATTLIST_NONE:
       if (dtd->keepProcessing && parser->m_attlistDeclHandler)
         handleDefault = XML_FALSE;
       break;
     case XML_ROLE_ELEMENT_NONE:
       if (parser->m_elementDeclHandler)
         handleDefault = XML_FALSE;
       break;
     } /* end of big switch */
 
     if (handleDefault && parser->m_defaultHandler)
       reportDefault(parser, enc, s, next);
 
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_FINISHED:
       return XML_ERROR_ABORTED;
     default:
       s = next;
       tok = XmlPrologTok(enc, s, end, &next);
     }
   }
   /* not reached */
 }
 
 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 (;;) {
     const char *next = NULL;
     int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
     parser->m_eventEndPtr = next;
     switch (tok) {
     /* report partial linebreak - it might be the last token */
     case -XML_TOK_PROLOG_S:
       if (parser->m_defaultHandler) {
         reportDefault(parser, parser->m_encoding, s, next);
         if (parser->m_parsingStatus.parsing == XML_FINISHED)
           return XML_ERROR_ABORTED;
       }
       *nextPtr = next;
       return XML_ERROR_NONE;
     case XML_TOK_NONE:
       *nextPtr = s;
       return XML_ERROR_NONE;
     case XML_TOK_PROLOG_S:
       if (parser->m_defaultHandler)
         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;
       }
       return XML_ERROR_PARTIAL_CHAR;
     default:
       return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
     }
     parser->m_eventPtr = s = next;
     switch (parser->m_parsingStatus.parsing) {
     case XML_SUSPENDED:
       *nextPtr = next;
       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;
   OPEN_INTERNAL_ENTITY *openEntity;
 
   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;
   entity->processed = 0;
   openEntity->next = parser->m_openInternalEntities;
   parser->m_openInternalEntities = openEntity;
   openEntity->entity = entity;
   openEntity->startTagLevel = parser->m_tagLevel;
   openEntity->betweenDecl = betweenDecl;
   openEntity->internalEventPtr = NULL;
   openEntity->internalEventEndPtr = NULL;
   textStart = (char *)entity->textPtr;
   textEnd = (char *)(entity->textPtr + entity->textLen);
   /* Set a safe default value in case 'next' does not get set */
   next = textStart;
 
 #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 */
       openEntity->next = parser->m_freeInternalEntities;
       parser->m_freeInternalEntities = openEntity;
     }
   }
   return result;
 }
 
 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;
   textStart = ((char *)entity->textPtr) + entity->processed;
   textEnd = (char *)(entity->textPtr + entity->textLen);
   /* Set a safe default value in case 'next' does not get set */
   next = textStart;
 
 #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 */
     openEntity->next = parser->m_freeInternalEntities;
     parser->m_freeInternalEntities = openEntity;
   }
 
 #ifdef XML_DTD
   if (entity->is_param) {
     int tok;
     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);
     switch (tok) {
     case XML_TOK_NONE:
       return XML_ERROR_NONE;
     case XML_TOK_INVALID:
       if (enc == parser->m_encoding)
         parser->m_eventPtr = next;
       return XML_ERROR_INVALID_TOKEN;
     case XML_TOK_PARTIAL:
       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:
       next = ptr + enc->minBytesPerChar;
       /* 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;
+            (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 */
         }
-        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;
-        }
+        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.
        * Getting that would require an entity name to contain an
        * incomplete XML character (e.g. \xE2\x82); however previous
        * tokenisers will have already recognised and rejected such
        * names before XmlAttributeValueTok() gets a look-in.  This
        * default case should be retained as a safety net, but the code
        * excluded from coverage tests.
        *
        * LCOV_EXCL_START
        */
       if (enc == parser->m_encoding)
         parser->m_eventPtr = ptr;
       return XML_ERROR_UNEXPECTED_STATE;
       /* LCOV_EXCL_STOP */
     }
     ptr = next;
   }
   /* not reached */
 }
 
 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
   int oldInEntityValue = parser->m_prologState.inEntityValue;
   parser->m_prologState.inEntityValue = 1;
 #endif /* XML_DTD */
   /* 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;
   }
 
   for (;;) {
     const char *next;
     int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
     switch (tok) {
     case XML_TOK_PARAM_ENTITY_REF:
 #ifdef XML_DTD
       if (parser->m_isParamEntity || enc != parser->m_encoding) {
         const XML_Char *name;
         ENTITY *entity;
         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
           if (parser->m_skippedEntityHandler)
             parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
           */
           dtd->keepProcessing = dtd->standalone;
           goto endEntityValue;
         }
         if (entity->open) {
           if (enc == parser->m_encoding)
             parser->m_eventPtr = entityTextPtr;
           result = XML_ERROR_RECURSIVE_ENTITY_REF;
           goto endEntityValue;
         }
         if (entity->systemId) {
           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;
         }
         break;
       }
 #endif /* XML_DTD */
       /* In the internal subset, PE references are not legal
          within markup declarations, e.g entity values in this case. */
       parser->m_eventPtr = entityTextPtr;
       result = XML_ERROR_PARAM_ENTITY_REF;
       goto endEntityValue;
     case XML_TOK_NONE:
       result = XML_ERROR_NONE;
       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;
       }
       break;
     case XML_TOK_TRAILING_CR:
       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;
       result = XML_ERROR_INVALID_TOKEN;
       goto endEntityValue;
     case XML_TOK_INVALID:
       if (enc == parser->m_encoding)
         parser->m_eventPtr = next;
       result = XML_ERROR_INVALID_TOKEN;
       goto endEntityValue;
     default:
       /* This default case should be unnecessary -- all the tokens
        * that XmlEntityValueTok() can return have their own explicit
        * cases -- but should be retained for safety.  We do however
        * exclude it from the coverage statistics.
        *
        * LCOV_EXCL_START
        */
       if (enc == parser->m_encoding)
         parser->m_eventPtr = entityTextPtr;
       result = XML_ERROR_UNEXPECTED_STATE;
       goto endEntityValue;
       /* LCOV_EXCL_STOP */
     }
     entityTextPtr = next;
   }
 endEntityValue:
 #ifdef XML_DTD
   parser->m_prologState.inEntityValue = oldInEntityValue;
 #endif /* XML_DTD */
   return result;
 }
 
 static void FASTCALL
-normalizeLines(XML_Char *s)
-{
+normalizeLines(XML_Char *s) {
   XML_Char *p;
   for (;; s++) {
     if (*s == XML_T('\0'))
       return;
     if (*s == 0xD)
       break;
   }
   p = s;
   do {
     if (*s == 0xD) {
       *p++ = 0xA;
       if (*++s == 0xA)
         s++;
-    }
-    else
+    } else
       *p++ = *s++;
   } while (*s);
   *p = XML_T('\0');
 }
 
 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;
   }
   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);
   poolClear(&parser->m_tempPool);
   return 1;
 }
 
 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);
   poolClear(&parser->m_tempPool);
   return 1;
 }
 
 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;
     const char **eventEndPP;
     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
        * conversion to the internal format (UTF-8 unless XML_UNICODE
        * is defined).  The only occasions on which the encoding passed
        * in is not the same as the parser's encoding are when it is
        * the internal encoding (e.g. a previously defined parameter
        * entity, already converted to internal format).  This by
        * definition doesn't need conversion, so the whole branch never
        * gets executed.
        *
        * For safety's sake we don't delete these lines and merely
        * exclude them from coverage statistics.
        *
        * LCOV_EXCL_START
        */
       eventPP = &(parser->m_openInternalEntities->internalEventPtr);
       eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
       /* LCOV_EXCL_STOP */
     }
     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
        a default which duplicates a non-default. */
     int i;
     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;
       type->defaultAtts = temp;
     }
   }
   att = type->defaultAtts + type->nDefaultAtts;
   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);
           else
             poolDiscard(&dtd->pool);
           break;
         }
       }
     }
   }
   return id;
 }
 
 #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.
          *
          * This is part of a loop copying the default prefix binding
          * URI into the parser's temporary string pool.  Previously,
          * that URI was copied into the same string pool, with a
          * terminating NUL character, as part of setContext().  When
          * the pool was cleared, that leaves a block definitely big
          * enough to hold the URI on the free block list of the pool.
          * The URI copy in getContext() therefore cannot run out of
          * memory.
          *
          * If the pool is used between the setContext() and
          * getContext() calls, the worst it can do is leave a bigger
          * block on the front of the free list.  Given that this is
          * all somewhat inobvious and program logic can be changed, we
          * don't delete the line but we do exclude it from the test
          * coverage statistics.
          */
         return NULL; /* LCOV_EXCL_LINE */
       }
     }
     needSep = XML_TRUE;
   }
 
   hashTableIterInit(&iter, &(dtd->prefixes));
   for (;;) {
     int i;
     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.
        * The test should remain for safety's sake, so we instead
        * exclude the following line from the coverage statistics.
        */
       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++;
     }
   }
   return XML_TRUE;
 }
 
 static void FASTCALL
-normalizePublicId(XML_Char *publicId)
-{
+normalizePublicId(XML_Char *publicId) {
   XML_Char *p = publicId;
   XML_Char *s;
   for (s = publicId; *s; s++) {
     switch (*s) {
     case 0x20:
     case 0xD:
     case 0xA:
       if (p != publicId && p[-1] != 0x20)
         *p++ = 0x20;
       break;
     default:
       *p++ = *s;
     }
   }
   if (p != publicId && p[-1] == 0x20)
     --p;
   *p = XML_T('\0');
 }
 
 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;
   poolInit(&(p->pool), ms);
   poolInit(&(p->entityValuePool), ms);
   hashTableInit(&(p->generalEntities), ms);
   hashTableInit(&(p->elementTypes), ms);
   hashTableInit(&(p->attributeIds), ms);
   hashTableInit(&(p->prefixes), ms);
 #ifdef XML_DTD
   p->paramEntityRead = XML_FALSE;
   hashTableInit(&(p->paramEntities), ms);
 #endif /* XML_DTD */
   p->defaultPrefix.name = NULL;
   p->defaultPrefix.binding = NULL;
 
   p->in_eldecl = XML_FALSE;
   p->scaffIndex = NULL;
   p->scaffold = NULL;
   p->scaffLevel = 0;
   p->scaffSize = 0;
   p->scaffCount = 0;
   p->contentStringLen = 0;
 
   p->keepProcessing = XML_TRUE;
   p->hasParamEntityRefs = XML_FALSE;
   p->standalone = XML_FALSE;
   return p;
 }
 
 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);
   }
   hashTableClear(&(p->generalEntities));
 #ifdef XML_DTD
   p->paramEntityRead = XML_FALSE;
   hashTableClear(&(p->paramEntities));
 #endif /* XML_DTD */
   hashTableClear(&(p->elementTypes));
   hashTableClear(&(p->attributeIds));
   hashTableClear(&(p->prefixes));
   poolClear(&(p->pool));
   poolClear(&(p->entityValuePool));
   p->defaultPrefix.name = NULL;
   p->defaultPrefix.binding = NULL;
 
   p->in_eldecl = XML_FALSE;
 
   ms->free_fcn(p->scaffIndex);
   p->scaffIndex = NULL;
   ms->free_fcn(p->scaffold);
   p->scaffold = NULL;
 
   p->scaffLevel = 0;
   p->scaffSize = 0;
   p->scaffCount = 0;
   p->contentStringLen = 0;
 
   p->keepProcessing = XML_TRUE;
   p->hasParamEntityRefs = XML_FALSE;
   p->standalone = XML_FALSE;
 }
 
 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);
   }
   hashTableDestroy(&(p->generalEntities));
 #ifdef XML_DTD
   hashTableDestroy(&(p->paramEntities));
 #endif /* XML_DTD */
   hashTableDestroy(&(p->elementTypes));
   hashTableDestroy(&(p->attributeIds));
   hashTableDestroy(&(p->prefixes));
   poolDestroy(&(p->pool));
   poolDestroy(&(p->entityValuePool));
   if (isDocEntity) {
     ms->free_fcn(p->scaffIndex);
     ms->free_fcn(p->scaffold);
   }
   ms->free_fcn(p);
 }
 
 /* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
    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. */
 
   hashTableIterInit(&iter, &(oldDtd->prefixes));
   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;
   }
 
   hashTableIterInit(&iter, &(oldDtd->attributeIds));
 
   /* Copy the attribute id table. */
 
   for (;;) {
     ATTRIBUTE_ID *newA;
     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) {
       newA->xmlns = oldA->xmlns;
       if (oldA->prefix == &oldDtd->defaultPrefix)
         newA->prefix = &newDtd->defaultPrefix;
       else
         newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
                                         oldA->prefix->name, 0);
     }
   }
 
   /* Copy the element type table. */
 
   hashTableIterInit(&iter, &(oldDtd->elementTypes));
 
   for (;;) {
     int i;
     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 */
 
   newDtd->keepProcessing = oldDtd->keepProcessing;
   newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
   newDtd->standalone = oldDtd->standalone;
 
   /* Don't want deep copying for scaffolding */
   newDtd->in_eldecl = oldDtd->in_eldecl;
   newDtd->scaffold = oldDtd->scaffold;
   newDtd->contentStringLen = oldDtd->contentStringLen;
   newDtd->scaffSize = oldDtd->scaffSize;
   newDtd->scaffLevel = oldDtd->scaffLevel;
   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;
 
   hashTableIterInit(&iter, oldTable);
 
   for (;;) {
     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) {
         if (oldE->base == cachedOldBase)
           newE->base = cachedNewBase;
         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;
     }
     newE->is_param = oldE->is_param;
     newE->is_internal = oldE->is_internal;
   }
   return 1;
 }
 
 #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;
   return XML_FALSE;
 }
 
 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;
   copy_salt_to_sipkey(parser, &key);
   sip24_init(&state, &key);
   sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
   return (unsigned long)sip24_final(&state);
 }
 
 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;
     i = h & mask;
     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) */
     if (table->used >> (table->power - 1)) {
       unsigned char newPower = table->power + 1;
       size_t newSize = (size_t)1 << newPower;
       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++)
         if (table->v[i]) {
           unsigned long newHash = hash(parser, table->v[i]->name);
           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);
           }
           newV[j] = table->v[i];
         }
       table->mem->free_fcn(table->v);
       table->v = newV;
       table->power = newPower;
       table->size = newSize;
       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;
   (table->used)++;
   return table->v[i];
 }
 
 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]);
     table->v[i] = NULL;
   }
   table->used = 0;
 }
 
 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]);
   table->mem->free_fcn(table->v);
 }
 
 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;
   p->v = NULL;
   p->mem = 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)
       return tem;
   }
   return NULL;
 }
 
 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;
   pool->ptr = NULL;
   pool->end = NULL;
   pool->mem = 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;
     while (p) {
       BLOCK *tem = p->next;
       p->next = pool->freeBlocks;
       pool->freeBlocks = p;
       p = tem;
     }
   }
   pool->blocks = NULL;
   pool->start = NULL;
   pool->ptr = NULL;
   pool->end = NULL;
 }
 
 static void FASTCALL
-poolDestroy(STRING_POOL *pool)
-{
+poolDestroy(STRING_POOL *pool) {
   BLOCK *p = pool->blocks;
   while (p) {
     BLOCK *tem = p->next;
     pool->mem->free_fcn(p);
     p = tem;
   }
   p = pool->freeBlocks;
   while (p) {
     BLOCK *tem = p->next;
     pool->mem->free_fcn(p);
     p = tem;
   }
 }
 
 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;
   poolFinish(pool);
   return 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
      * point, the name of the entity is already stored in the pool, so
      * pool->ptr cannot be NULL.
      *
      * If poolCopyStringN() is used elsewhere as it well might be,
      * this line may well become executable again.  Regardless, this
      * sort of check shouldn't be removed lightly, so we just exclude
      * it from the coverage statistics.
      */
     return NULL; /* LCOV_EXCL_LINE */
   }
   for (; n > 0; --n, s++) {
-    if (!poolAppendChar(pool, *s))
+    if (! poolAppendChar(pool, *s))
       return NULL;
   }
   s = pool->start;
   poolFinish(pool);
   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++;
   }
   return pool->start;
 }
 
 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);
   **
   ** Detect overflow, avoiding _signed_ overflow undefined behavior
   ** 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;
 
   if (blockSize > (int)(INT_MAX / stretch))
     return 0;
 
   {
     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;
 
     return (size_t)bytesToAllocate;
   }
 }
 
 static XML_Bool FASTCALL
-poolGrow(STRING_POOL *pool)
-{
+poolGrow(STRING_POOL *pool) {
   if (pool->freeBlocks) {
     if (pool->start == 0) {
       pool->blocks = pool->freeBlocks;
       pool->freeBlocks = pool->freeBlocks->next;
       pool->blocks->next = NULL;
       pool->start = pool->blocks->s;
       pool->end = pool->start + pool->blocks->size;
       pool->ptr = pool->start;
       return XML_TRUE;
     }
     if (pool->end - pool->start < pool->freeBlocks->size) {
       BLOCK *tem = pool->freeBlocks->next;
       pool->freeBlocks->next = pool->blocks;
       pool->blocks = pool->freeBlocks;
       pool->freeBlocks = tem;
       memcpy(pool->blocks->s, pool->start,
              (pool->end - pool->start) * sizeof(XML_Char));
       pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
       pool->start = pool->blocks->s;
       pool->end = pool->start + pool->blocks->size;
       return XML_TRUE;
     }
   }
   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`
              to avoid dangling pointers: */
     const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
 
     if (blockSize < 0) {
       /* This condition traps a situation where either more than
        * INT_MAX/2 bytes have already been allocated.  This isn't
        * readily testable, since it is unlikely that an average
        * machine will have that much memory, so we exclude it from the
        * coverage statistics.
        */
       return XML_FALSE; /* LCOV_EXCL_LINE */
     }
 
     bytesToAllocate = poolBytesToAllocateFor(blockSize);
     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;
     pool->blocks->size = blockSize;
     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;
 
     if (blockSize < 0) {
       /* This condition traps a situation where either more than
        * INT_MAX bytes have already been allocated (which is prevented
        * by various pieces of program logic, not least this one, never
        * mind the unlikelihood of actually having that much memory) or
        * the pool control fields have been corrupted (which could
        * conceivably happen in an extremely buggy user handler
        * 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)
       blockSize = INIT_BLOCK_SIZE;
     else {
       /* Detect overflow, avoiding _signed_ overflow undefined behavior */
       if ((int)((unsigned)blockSize * 2U) < 0) {
         return XML_FALSE;
       }
       blockSize *= 2;
     }
 
     bytesToAllocate = poolBytesToAllocateFor(blockSize);
     if (bytesToAllocate == 0)
       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;
   }
   return XML_TRUE;
 }
 
 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;
   }
 
   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;
     }
     dtd->scaffold = temp;
   }
   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++;
   }
   me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
   return next;
 }
 
 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) {
     const XML_Char *src;
     dest->name = *strpos;
     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);
     }
     dest->name = NULL;
   }
 }
 
 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);
   return ret;
 }
 
 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;
+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 */
+  /* 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;
 }
Index: vendor/expat/dist/lib/xmlrole.c
===================================================================
--- vendor/expat/dist/lib/xmlrole.c	(revision 355070)
+++ vendor/expat/dist/lib/xmlrole.c	(revision 355071)
@@ -1,1386 +1,1247 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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"
 #include "internal.h"
 #include "xmlrole.h"
 #include "ascii.h"
 
 /* Doesn't check:
 
  that ,| are not mixed in a model group
  content of literals
 
 */
 
-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;
     return XML_ROLE_NONE;
   case XML_TOK_XML_DECL:
     state->handler = prolog1;
     return XML_ROLE_XML_DECL;
   case XML_TOK_PI:
     state->handler = prolog1;
     return XML_ROLE_PI;
   case XML_TOK_COMMENT:
     state->handler = prolog1;
     return XML_ROLE_COMMENT;
   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;
   case XML_TOK_INSTANCE_START:
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_PI:
     return XML_ROLE_PI;
   case XML_TOK_COMMENT:
     return XML_ROLE_COMMENT;
   case XML_TOK_BOM:
     /* This case can never arise.  To reach this role function, the
      * parse must have passed through prolog0 and therefore have had
      * some form of input, even if only a space.  At that point, a
      * byte order mark is no longer a valid character (though
      * technically it should be interpreted as a non-breaking space),
      * so will be rejected by the tokenizing stages.
      */
     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;
   case XML_TOK_INSTANCE_START:
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_PI:
     return XML_ROLE_PI;
   case XML_TOK_COMMENT:
     return XML_ROLE_COMMENT;
   case XML_TOK_INSTANCE_START:
     state->handler = error;
     return XML_ROLE_INSTANCE_START;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = doctype1;
     return XML_ROLE_DOCTYPE_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_BRACKET:
     state->handler = internalSubset;
     return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
   case XML_TOK_DECL_CLOSE:
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = doctype3;
       return XML_ROLE_DOCTYPE_NONE;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = doctype2;
       return XML_ROLE_DOCTYPE_NONE;
     }
     break;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = doctype3;
     return XML_ROLE_DOCTYPE_PUBLIC_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = doctype4;
     return XML_ROLE_DOCTYPE_SYSTEM_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_BRACKET:
     state->handler = internalSubset;
     return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
   case XML_TOK_DECL_CLOSE:
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_DECL_CLOSE:
     state->handler = prolog2;
     return XML_ROLE_DOCTYPE_CLOSE;
   }
   return common(state, tok);
 }
 
 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;
     }
     break;
   case XML_TOK_PI:
     return XML_ROLE_PI;
   case XML_TOK_COMMENT:
     return XML_ROLE_COMMENT;
   case XML_TOK_PARAM_ENTITY_REF:
     return XML_ROLE_PARAM_ENTITY_REF;
   case XML_TOK_CLOSE_BRACKET:
     state->handler = doctype5;
     return XML_ROLE_DOCTYPE_NONE;
   case XML_TOK_NONE:
     return XML_ROLE_NONE;
   }
   return common(state, tok);
 }
 
 #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;
   return externalSubset1(state, tok, ptr, end, enc);
 }
 
 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;
     return XML_ROLE_NONE;
   case XML_TOK_COND_SECT_CLOSE:
     if (state->includeLevel == 0)
       break;
     state->includeLevel -= 1;
     return XML_ROLE_NONE;
   case XML_TOK_PROLOG_S:
     return XML_ROLE_NONE;
   case XML_TOK_CLOSE_BRACKET:
     break;
   case XML_TOK_NONE:
     if (state->includeLevel)
       break;
     return XML_ROLE_NONE;
   default:
     return internalSubset(state, tok, ptr, end, enc);
   }
   return common(state, tok);
 }
 
 #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;
   case XML_TOK_PERCENT:
     state->handler = entity1;
     return XML_ROLE_ENTITY_NONE;
   case XML_TOK_NAME:
     state->handler = entity2;
     return XML_ROLE_GENERAL_ENTITY_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     state->handler = entity7;
     return XML_ROLE_PARAM_ENTITY_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = entity4;
       return XML_ROLE_ENTITY_NONE;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = entity3;
       return XML_ROLE_ENTITY_NONE;
     }
     break;
   case XML_TOK_LITERAL:
     state->handler = declClose;
     state->role_none = XML_ROLE_ENTITY_NONE;
     return XML_ROLE_ENTITY_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = entity4;
     return XML_ROLE_ENTITY_PUBLIC_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = entity5;
     return XML_ROLE_ENTITY_SYSTEM_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_DECL_CLOSE:
     setTopLevel(state);
     return XML_ROLE_ENTITY_COMPLETE;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
       state->handler = entity6;
       return XML_ROLE_ENTITY_NONE;
     }
     break;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     state->handler = declClose;
     state->role_none = XML_ROLE_ENTITY_NONE;
     return XML_ROLE_ENTITY_NOTATION_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = entity9;
       return XML_ROLE_ENTITY_NONE;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = entity8;
       return XML_ROLE_ENTITY_NONE;
     }
     break;
   case XML_TOK_LITERAL:
     state->handler = declClose;
     state->role_none = XML_ROLE_ENTITY_NONE;
     return XML_ROLE_ENTITY_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = entity9;
     return XML_ROLE_ENTITY_PUBLIC_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = entity10;
     return XML_ROLE_ENTITY_SYSTEM_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_DECL_CLOSE:
     setTopLevel(state);
     return XML_ROLE_ENTITY_COMPLETE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     state->handler = notation1;
     return XML_ROLE_NOTATION_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
       state->handler = notation3;
       return XML_ROLE_NOTATION_NONE;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
       state->handler = notation2;
       return XML_ROLE_NOTATION_NONE;
     }
     break;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = notation4;
     return XML_ROLE_NOTATION_PUBLIC_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = declClose;
     state->role_none = XML_ROLE_NOTATION_NONE;
     return XML_ROLE_NOTATION_SYSTEM_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = declClose;
     state->role_none = XML_ROLE_NOTATION_NONE;
     return XML_ROLE_NOTATION_SYSTEM_ID;
   case XML_TOK_DECL_CLOSE:
     setTopLevel(state);
     return XML_ROLE_NOTATION_NO_SYSTEM_ID;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = attlist1;
     return XML_ROLE_ATTLIST_ELEMENT_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_DECL_CLOSE:
     setTopLevel(state);
     return XML_ROLE_ATTLIST_NONE;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = attlist2;
     return XML_ROLE_ATTRIBUTE_NAME;
   }
   return common(state, tok);
 }
 
 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;
     }
     break;
   case XML_TOK_OPEN_PAREN:
     state->handler = attlist3;
     return XML_ROLE_ATTLIST_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NMTOKEN:
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = attlist4;
     return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_CLOSE_PAREN:
     state->handler = attlist8;
     return XML_ROLE_ATTLIST_NONE;
   case XML_TOK_OR:
     state->handler = attlist3;
     return XML_ROLE_ATTLIST_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_PAREN:
     state->handler = attlist6;
     return XML_ROLE_ATTLIST_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     state->handler = attlist7;
     return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_CLOSE_PAREN:
     state->handler = attlist8;
     return XML_ROLE_ATTLIST_NONE;
   case XML_TOK_OR:
     state->handler = attlist6;
     return XML_ROLE_ATTLIST_NONE;
   }
   return common(state, tok);
 }
 
 /* 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;
     }
     break;
   case XML_TOK_LITERAL:
     state->handler = attlist1;
     return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_LITERAL:
     state->handler = attlist1;
     return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = element1;
     return XML_ROLE_ELEMENT_NAME;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
       return XML_ROLE_CONTENT_EMPTY;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
       return XML_ROLE_CONTENT_ANY;
     }
     break;
   case XML_TOK_OPEN_PAREN:
     state->handler = element2;
     state->level = 1;
     return XML_ROLE_GROUP_OPEN;
   }
   return common(state, tok);
 }
 
 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;
     }
     break;
   case XML_TOK_OPEN_PAREN:
     state->level = 2;
     state->handler = element6;
     return XML_ROLE_GROUP_OPEN;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT;
   case XML_TOK_NAME_QUESTION:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_OPT;
   case XML_TOK_NAME_ASTERISK:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_REP;
   case XML_TOK_NAME_PLUS:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_PLUS;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_CLOSE_PAREN:
     state->handler = declClose;
     state->role_none = XML_ROLE_ELEMENT_NONE;
     return XML_ROLE_GROUP_CLOSE;
   case XML_TOK_CLOSE_PAREN_ASTERISK:
     state->handler = declClose;
     state->role_none = XML_ROLE_ELEMENT_NONE;
     return XML_ROLE_GROUP_CLOSE_REP;
   case XML_TOK_OR:
     state->handler = element4;
     return XML_ROLE_ELEMENT_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = element5;
     return XML_ROLE_CONTENT_ELEMENT;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_CLOSE_PAREN_ASTERISK:
     state->handler = declClose;
     state->role_none = XML_ROLE_ELEMENT_NONE;
     return XML_ROLE_GROUP_CLOSE_REP;
   case XML_TOK_OR:
     state->handler = element4;
     return XML_ROLE_ELEMENT_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_PAREN:
     state->level += 1;
     return XML_ROLE_GROUP_OPEN;
   case XML_TOK_NAME:
   case XML_TOK_PREFIXED_NAME:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT;
   case XML_TOK_NAME_QUESTION:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_OPT;
   case XML_TOK_NAME_ASTERISK:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_REP;
   case XML_TOK_NAME_PLUS:
     state->handler = element7;
     return XML_ROLE_CONTENT_ELEMENT_PLUS;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_CLOSE_PAREN:
     state->level -= 1;
     if (state->level == 0) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
     }
     return XML_ROLE_GROUP_CLOSE;
   case XML_TOK_CLOSE_PAREN_ASTERISK:
     state->level -= 1;
     if (state->level == 0) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
     }
     return XML_ROLE_GROUP_CLOSE_REP;
   case XML_TOK_CLOSE_PAREN_QUESTION:
     state->level -= 1;
     if (state->level == 0) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
     }
     return XML_ROLE_GROUP_CLOSE_OPT;
   case XML_TOK_CLOSE_PAREN_PLUS:
     state->level -= 1;
     if (state->level == 0) {
       state->handler = declClose;
       state->role_none = XML_ROLE_ELEMENT_NONE;
     }
     return XML_ROLE_GROUP_CLOSE_PLUS;
   case XML_TOK_COMMA:
     state->handler = element6;
     return XML_ROLE_GROUP_SEQUENCE;
   case XML_TOK_OR:
     state->handler = element6;
     return XML_ROLE_GROUP_CHOICE;
   }
   return common(state, tok);
 }
 
 #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;
   case XML_TOK_NAME:
     if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
       state->handler = condSect1;
       return XML_ROLE_NONE;
     }
     if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
       state->handler = condSect2;
       return XML_ROLE_NONE;
     }
     break;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_BRACKET:
     state->handler = externalSubset1;
     state->includeLevel += 1;
     return XML_ROLE_NONE;
   }
   return common(state, tok);
 }
 
 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;
   case XML_TOK_OPEN_BRACKET:
     state->handler = externalSubset1;
     return XML_ROLE_IGNORE_SECT;
   }
   return common(state, tok);
 }
 
 #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;
   case XML_TOK_DECL_CLOSE:
     setTopLevel(state);
     return state->role_none;
   }
   return common(state, tok);
 }
 
 /* This function will only be invoked if the internal logic of the
  * parser has broken down.  It is used in two cases:
  *
  * 1: When the XML prolog has been finished.  At this point the
  * processor (the parser level above these role handlers) should
  * switch from prologProcessor to contentProcessor and reinitialise
  * the handler function.
  *
  * 2: When an error has been detected (via common() below).  At this
  * point again the processor should be switched to errorProcessor,
  * which will never call a handler.
  *
  * The result of this is that error() can only be called if the
  * processor switch failed to happen, which is an internal error and
  * therefore we shouldn't be able to provoke it simply by using the
  * library.  It is a necessary backstop, however, so we merely exclude
  * it from the coverage statistics.
  *
  * 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;
   return XML_ROLE_ERROR;
 }
 
 void
-XmlPrologStateInit(PROLOG_STATE *state)
-{
+XmlPrologStateInit(PROLOG_STATE *state) {
   state->handler = prolog0;
 #ifdef XML_DTD
   state->documentEntity = 1;
   state->includeLevel = 0;
   state->inEntityValue = 0;
 #endif /* XML_DTD */
 }
 
 #ifdef XML_DTD
 
 void
-XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
-{
+XmlPrologStateInitExternalEntity(PROLOG_STATE *state) {
   state->handler = externalSubset0;
   state->documentEntity = 0;
   state->includeLevel = 0;
 }
 
 #endif /* XML_DTD */
Index: vendor/expat/dist/lib/xmlrole.h
===================================================================
--- vendor/expat/dist/lib/xmlrole.h	(revision 355070)
+++ vendor/expat/dist/lib/xmlrole.h	(revision 355071)
@@ -1,142 +1,139 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifndef XmlRole_INCLUDED
 #define XmlRole_INCLUDED 1
 
 #ifdef __VMS
 /*      0        1         2         3      0        1         2         3
         1234567890123456789012345678901     1234567890123456789012345678901 */
-#define XmlPrologStateInitExternalEntity    XmlPrologStateInitExternalEnt
+#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
 #endif
 
 #include "xmltok.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 enum {
   XML_ROLE_ERROR = -1,
   XML_ROLE_NONE = 0,
   XML_ROLE_XML_DECL,
   XML_ROLE_INSTANCE_START,
   XML_ROLE_DOCTYPE_NONE,
   XML_ROLE_DOCTYPE_NAME,
   XML_ROLE_DOCTYPE_SYSTEM_ID,
   XML_ROLE_DOCTYPE_PUBLIC_ID,
   XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
   XML_ROLE_DOCTYPE_CLOSE,
   XML_ROLE_GENERAL_ENTITY_NAME,
   XML_ROLE_PARAM_ENTITY_NAME,
   XML_ROLE_ENTITY_NONE,
   XML_ROLE_ENTITY_VALUE,
   XML_ROLE_ENTITY_SYSTEM_ID,
   XML_ROLE_ENTITY_PUBLIC_ID,
   XML_ROLE_ENTITY_COMPLETE,
   XML_ROLE_ENTITY_NOTATION_NAME,
   XML_ROLE_NOTATION_NONE,
   XML_ROLE_NOTATION_NAME,
   XML_ROLE_NOTATION_SYSTEM_ID,
   XML_ROLE_NOTATION_NO_SYSTEM_ID,
   XML_ROLE_NOTATION_PUBLIC_ID,
   XML_ROLE_ATTRIBUTE_NAME,
   XML_ROLE_ATTRIBUTE_TYPE_CDATA,
   XML_ROLE_ATTRIBUTE_TYPE_ID,
   XML_ROLE_ATTRIBUTE_TYPE_IDREF,
   XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
   XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
   XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
   XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
   XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
   XML_ROLE_ATTRIBUTE_ENUM_VALUE,
   XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
   XML_ROLE_ATTLIST_NONE,
   XML_ROLE_ATTLIST_ELEMENT_NAME,
   XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
   XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
   XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
   XML_ROLE_FIXED_ATTRIBUTE_VALUE,
   XML_ROLE_ELEMENT_NONE,
   XML_ROLE_ELEMENT_NAME,
   XML_ROLE_CONTENT_ANY,
   XML_ROLE_CONTENT_EMPTY,
   XML_ROLE_CONTENT_PCDATA,
   XML_ROLE_GROUP_OPEN,
   XML_ROLE_GROUP_CLOSE,
   XML_ROLE_GROUP_CLOSE_REP,
   XML_ROLE_GROUP_CLOSE_OPT,
   XML_ROLE_GROUP_CLOSE_PLUS,
   XML_ROLE_GROUP_CHOICE,
   XML_ROLE_GROUP_SEQUENCE,
   XML_ROLE_CONTENT_ELEMENT,
   XML_ROLE_CONTENT_ELEMENT_REP,
   XML_ROLE_CONTENT_ELEMENT_OPT,
   XML_ROLE_CONTENT_ELEMENT_PLUS,
   XML_ROLE_PI,
   XML_ROLE_COMMENT,
 #ifdef XML_DTD
   XML_ROLE_TEXT_DECL,
   XML_ROLE_IGNORE_SECT,
   XML_ROLE_INNER_PARAM_ENTITY_REF,
 #endif /* XML_DTD */
   XML_ROLE_PARAM_ENTITY_REF
 };
 
 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
   unsigned includeLevel;
   int documentEntity;
   int inEntityValue;
 #endif /* XML_DTD */
 } PROLOG_STATE;
 
 void XmlPrologStateInit(PROLOG_STATE *);
 #ifdef XML_DTD
 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
 }
 #endif
 
 #endif /* not XmlRole_INCLUDED */
Index: vendor/expat/dist/lib/xmltok.c
===================================================================
--- vendor/expat/dist/lib/xmltok.c	(revision 355070)
+++ vendor/expat/dist/lib/xmltok.c	(revision 355071)
@@ -1,1806 +1,1672 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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"
 #include "internal.h"
 #include "xmltok.h"
 #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_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_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/
    with the additional restriction of not allowing the Unicode
    code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
    Implementation details:
      (A & 0x80) == 0     means A < 0x80
    and
      (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_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_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);
 }
 
 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 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 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);
 
 #include "xmltok_impl.h"
 #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
 
 #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
 
-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;
     }
   }
   *fromLimRef = fromLim;
 }
 
 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;
   }
 
   /* 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;
     }
   }
 
   {
     const ptrdiff_t bytesToCopy = fromLim - *fromP;
     memcpy(*toP, *fromP, bytesToCopy);
     *fromP += bytesToCopy;
     *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;
   else
     return XML_CONVERT_COMPLETED;
 }
 
 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;
   while (from < fromLim && to < toLim) {
     switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
     case BT_LEAD2:
       if (fromLim - from < 2) {
         res = XML_CONVERT_INPUT_INCOMPLETE;
         goto after;
       }
       *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
       from += 2;
       break;
     case BT_LEAD3:
       if (fromLim - from < 3) {
         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;
     }
   }
   if (from < fromLim)
     res = XML_CONVERT_OUTPUT_EXHAUSTED;
 after:
   *fromP = from;
   *toP = to;
   return res;
 }
 
 #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)
       return XML_CONVERT_COMPLETED;
     c = (unsigned char)**fromP;
     if (c & 0x80) {
       if (toLim - *toP < 2)
         return XML_CONVERT_OUTPUT_EXHAUSTED;
       *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
       *(*toP)++ = (char)((c & 0x3f) | 0x80);
       (*fromP)++;
-    }
-    else {
+    } else {
       if (*toP == toLim)
         return XML_CONVERT_OUTPUT_EXHAUSTED;
       *(*toP)++ = *(*fromP)++;
     }
   }
 }
 
 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)++;
 
   if ((*toP == toLim) && (*fromP < fromLim))
     return XML_CONVERT_OUTPUT_EXHAUSTED;
   else
     return XML_CONVERT_COMPLETED;
 }
 
 #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)++;
 
   if ((*toP == toLim) && (*fromP < fromLim))
     return XML_CONVERT_OUTPUT_EXHAUSTED;
   else
     return XML_CONVERT_COMPLETED;
 }
 
 #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;
   }
   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])
 
 DEFINE_UTF16_TO_UTF8(little2_)
 DEFINE_UTF16_TO_UTF16(little2_)
 
 #undef SET2
 #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])
 
 DEFINE_UTF16_TO_UTF8(big2_)
 DEFINE_UTF16_TO_UTF16(big2_)
 
 #undef SET2
 #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 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
+#  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
+#  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 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
+#  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
+#  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++;
     if (ASCII_a <= c1 && c1 <= ASCII_z)
       c1 += ASCII_A - ASCII_a;
     if (ASCII_a <= c2 && c2 <= ASCII_z)
       /* The following line will never get executed.  streqci() is
        * only called from two places, both of which guarantee to put
        * upper-case strings into 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);
   if (p == buf)
     return -1;
   else
     return buf[0];
 }
 
 static int FASTCALL
-isSpace(int c)
-{
+isSpace(int c) {
   switch (c) {
   case 0x20:
   case 0xD:
   case 0xA:
   case 0x9:
     return 1;
   }
   return 0;
 }
 
 /* Return 1 if there's just optional white space or there's an S
    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;
   }
   do {
     ptr += enc->minBytesPerChar;
   } while (isSpace(toAscii(enc, ptr, end)));
   if (ptr == end) {
     *namePtr = NULL;
     return 1;
   }
   *namePtr = ptr;
   for (;;) {
     c = toAscii(enc, ptr, end);
     if (c == -1) {
       *nextTokPtr = ptr;
       return 0;
     }
     if (c == ASCII_EQUALS) {
       *nameEndPtr = ptr;
       break;
     }
     if (isSpace(c)) {
       *nameEndPtr = ptr;
       do {
         ptr += enc->minBytesPerChar;
       } while (isSpace(c = toAscii(enc, ptr, end)));
       if (c != ASCII_EQUALS) {
         *nextTokPtr = ptr;
         return 0;
       }
       break;
     }
     ptr += enc->minBytesPerChar;
   }
   if (ptr == *namePtr) {
     *nextTokPtr = ptr;
     return 0;
   }
   ptr += enc->minBytesPerChar;
   c = toAscii(enc, ptr, end);
   while (isSpace(c)) {
     ptr += enc->minBytesPerChar;
     c = toAscii(enc, ptr, end);
   }
   if (c != ASCII_QUOT && c != ASCII_APOS) {
     *nextTokPtr = ptr;
     return 0;
   }
   open = (char)c;
   ptr += enc->minBytesPerChar;
   *valPtr = ptr;
   for (;; ptr += enc->minBytesPerChar) {
     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;
     }
   }
   *nextTokPtr = ptr + enc->minBytesPerChar;
   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;
         return 0;
       }
       return 1;
     }
   }
   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;
     }
     if (encodingName)
       *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;
   }
   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;
   }
   while (isSpace(toAscii(enc, ptr, end)))
     ptr += enc->minBytesPerChar;
   if (ptr != end) {
     *badPtr = ptr;
     return 0;
   }
   return 1;
 }
 
 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)
       return -1;
     break;
   case 0xFF:
     if (result == 0xFFFE || result == 0xFFFF)
       return -1;
     break;
   }
   return 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,
     min3 = 0x800,
     min4 = 0x10000
   };
 
   if (c < 0)
     return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
   if (c < min2) {
     buf[0] = (char)(c | UTF8_cval1);
     return 1;
   }
   if (c < min3) {
     buf[0] = (char)((c >> 6) | UTF8_cval2);
     buf[1] = (char)((c & 0x3f) | 0x80);
     return 2;
   }
   if (c < min4) {
     buf[0] = (char)((c >> 12) | UTF8_cval3);
     buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
     buf[2] = (char)((c & 0x3f) | 0x80);
     return 3;
   }
   if (c < 0x110000) {
     buf[0] = (char)((c >> 18) | UTF8_cval4);
     buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
     buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
     buf[3] = (char)((c & 0x3f) | 0x80);
     return 4;
   }
   return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */
 }
 
 int FASTCALL
-XmlUtf16Encode(int charNum, unsigned short *buf)
-{
+XmlUtf16Encode(int charNum, unsigned short *buf) {
   if (charNum < 0)
     return 0;
   if (charNum < 0x10000) {
     buf[0] = (unsigned short)charNum;
     return 1;
   }
   if (charNum < 0x110000) {
     charNum -= 0x10000;
     buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
     buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
     return 2;
   }
   return 0;
 }
 
 struct unknown_encoding {
   struct normal_encoding normal;
   CONVERTER convert;
   void *userData;
   unsigned short utf16[256];
   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)
     return 0;
   return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
 }
 
 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)
     return 0;
   return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
 }
 
 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 (;;) {
     const char *utf8;
     int n;
     if (*fromP == fromLim)
       return XML_CONVERT_COMPLETED;
     utf8 = uenc->utf8[(unsigned char)**fromP];
     n = *utf8++;
     if (n == 0) {
       int c = uenc->convert(uenc->userData, *fromP);
       n = XmlUtf8Encode(c, buf);
       if (n > toLim - *toP)
         return XML_CONVERT_OUTPUT_EXHAUSTED;
       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)++;
     }
     memcpy(*toP, utf8, n);
     *toP += n;
   }
 }
 
 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;
   }
 
   if ((*toP == toLim) && (*fromP < fromLim))
     return XML_CONVERT_OUTPUT_EXHAUSTED;
   else
     return XML_CONVERT_COMPLETED;
 }
 
 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];
     if (c == -1) {
       e->normal.type[i] = BT_MALFORM;
       /* This shouldn't really get used. */
       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))
         e->normal.type[i] = BT_NMSTRT;
       else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
         e->normal.type[i] = BT_NAME;
       else
         e->normal.type[i] = BT_OTHER;
       e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
       e->utf16[i] = (unsigned short)c;
     }
   }
   e->userData = userData;
   e->convert = convert;
   if (convert) {
     e->normal.isName2 = unknown_isName;
     e->normal.isName3 = unknown_isName;
     e->normal.isName4 = unknown_isName;
     e->normal.isNmstrt2 = unknown_isNmstrt;
     e->normal.isNmstrt3 = unknown_isNmstrt;
     e->normal.isNmstrt4 = unknown_isNmstrt;
     e->normal.isInvalid2 = unknown_isInvalid;
     e->normal.isInvalid3 = unknown_isInvalid;
     e->normal.isInvalid4 = unknown_isInvalid;
   }
   e->normal.enc.utf8Convert = unknown_toUtf8;
   e->normal.enc.utf16Convert = unknown_toUtf16;
   return &(e->normal.enc);
 }
 
 /* If this enumeration is changed, getEncodingIndex and encodings
 must also be changed. */
 enum {
   UNKNOWN_ENC = -1,
   ISO_8859_1_ENC = 0,
   US_ASCII_ENC,
   UTF_8_ENC,
   UTF_16_ENC,
   UTF_16BE_ENC,
   UTF_16LE_ENC,
   /* must match encodingNames up to here */
   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;
 }
 
 /* For binary compatibility, we store the index of the encoding
    specified at initialization in the isUtf16 member.
 */
 
 #define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
 #define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
 
 /* This is what detects the encoding.  encodingTable maps from
    encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
    the external (protocol) specified encoding; state is
    XML_CONTENT_STATE if we're parsing an external text entity, and
    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)
     return XML_TOK_NONE;
   encPtr = enc->encPtr;
   if (ptr + 1 == end) {
     /* only a single byte available for auto-detection */
 #ifndef XML_DTD /* FIXME */
     /* a well-formed document entity must have more than one byte */
     if (state != XML_CONTENT_STATE)
       return XML_TOK_PARTIAL;
 #endif
     /* so we're parsing an external text entity... */
     /* if UTF-16 was externally specified, then we need at least 2 bytes */
     switch (INIT_ENC_INDEX(enc)) {
     case UTF_16_ENC:
     case UTF_16LE_ENC:
     case UTF_16BE_ENC:
       return XML_TOK_PARTIAL;
     }
     switch ((unsigned char)*ptr) {
     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];
       return XML_TOK_BOM;
     /* 00 3C is handled in the default case */
     case 0x3C00:
       if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
            || INIT_ENC_INDEX(enc) == UTF_16_ENC)
           && state == XML_CONTENT_STATE)
         break;
       *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];
       return XML_TOK_BOM;
     case 0xEFBB:
       /* Maybe a UTF-8 BOM (EF BB BF) */
       /* If there's an explicitly specified (external) encoding
          of ISO-8859-1 or some flavour of UTF-16
          and this is an external text entity,
          don't look for the BOM,
          because it might be a legal data.
       */
       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)
         return XML_TOK_PARTIAL;
       if ((unsigned char)ptr[2] == 0xBF) {
         *nextTokPtr = ptr + 3;
         *encPtr = encodingTable[UTF_8_ENC];
         return XML_TOK_BOM;
       }
       break;
     default:
       if (ptr[0] == '\0') {
         /* 0 isn't a legal data character. Furthermore a document
            entity can only start with ASCII characters.  So the only
            way this can fail to be big-endian UTF-16 if it it's an
            external parsed general entity that's labelled as
            UTF-16LE.
         */
         if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
           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
             - no externally specified encoding
             - no encoding declaration
            by assuming UTF-16LE.  But we don't, because this would mean when
            presented just with a single byte, we couldn't reliably determine
            whether we needed further bytes.
         */
         if (state == XML_CONTENT_STATE)
           break;
         *encPtr = encodingTable[UTF_16LE_ENC];
         return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
       }
       break;
     }
   }
   *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
   return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
 }
 
-
 #define NS(x) x
 #define ns(x) x
 #define XML_TOK_NS_C
 #include "xmltok_ns.c"
 #undef XML_TOK_NS_C
 #undef NS
 #undef ns
 
 #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;
   return enc;
 }
 
 #endif /* XML_NS */
Index: vendor/expat/dist/lib/xmltok.h
===================================================================
--- vendor/expat/dist/lib/xmltok.h	(revision 355070)
+++ vendor/expat/dist/lib/xmltok.h	(revision 355071)
@@ -1,345 +1,315 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifndef XmlTok_INCLUDED
 #define XmlTok_INCLUDED 1
 
 #ifdef __cplusplus
 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
    returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
 */
 #define XML_TOK_START_TAG_WITH_ATTS 1
 #define XML_TOK_START_TAG_NO_ATTS 2
 #define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
 #define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
 #define XML_TOK_END_TAG 5
 #define XML_TOK_DATA_CHARS 6
 #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
 #define XML_TOK_OPEN_BRACKET 25
 #define XML_TOK_CLOSE_BRACKET 26
 #define XML_TOK_LITERAL 27
 #define XML_TOK_PARAM_ENTITY_REF 28
 #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 */
 #define XML_TOK_ATTRIBUTE_VALUE_S 39
 
 /* The following token is returned only by XmlCdataSectionTok */
 #define XML_TOK_CDATA_SECT_CLOSE 40
 
 /* With namespace processing this is returned by XmlPrologTok for a
    name with a colon.
 */
 #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
 #define XML_ATTRIBUTE_VALUE_LITERAL 0
 #define XML_ENTITY_VALUE_LITERAL 1
 
 /* The size of the buffer passed to XmlUtf8Encode must be at least this. */
 #define XML_UTF8_ENCODE_MAX 4
 /* The size of the buffer passed to XmlUtf16Encode must be at least this. */
 #define XML_UTF16_ENCODE_MAX 2
 
 typedef struct position {
   /* first line and first column are 0 not 1 */
   XML_Size lineNumber;
   XML_Size columnNumber;
 } POSITION;
 
 typedef struct {
   const char *name;
   const char *valuePtr;
   const char *valueEnd;
   char normalized;
 } ATTRIBUTE;
 
 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;
 };
 
 /* Scan the string starting at ptr until the end of the next complete
    token, but do not scan past eptr.  Return an integer giving the
    type of token.
 
    Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
 
    Return XML_TOK_PARTIAL when the string does not contain a complete
    token; nextTokPtr will not be set.
 
    Return XML_TOK_INVALID when the string does not start a valid
    token; nextTokPtr will be set to point to the character which made
    the token invalid.
 
    Otherwise the string starts with a valid token; nextTokPtr will be
    set to point to the character following the end of that token.
 
    Each data character counts as a single token, but adjacent data
    characters may be returned together.  Similarly for characters in
    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 {
   ENCODING initEnc;
   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);
 const ENCODING *XmlGetUtf16InternalEncoding(void);
 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
 
 #endif /* not XmlTok_INCLUDED */
Index: vendor/expat/dist/lib/xmltok_impl.c
===================================================================
--- vendor/expat/dist/lib/xmltok_impl.c	(revision 355070)
+++ vendor/expat/dist/lib/xmltok_impl.c	(revision 355071)
@@ -1,1763 +1,1804 @@
 /* This file is included!
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef XML_TOK_IMPL_C
 
-#ifndef IS_INVALID_CHAR
-#define IS_INVALID_CHAR(enc, ptr, n) (0)
-#endif
+#  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_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_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_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_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)
+#  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
+#  ifndef PREFIX
+#    define PREFIX(ident) ident
+#  endif
 
+#  define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
 
-#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 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_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;
           }
           *nextTokPtr = ptr + MINBPC(enc);
           return XML_TOK_COMMENT;
         }
         break;
       default:
         ptr += MINBPC(enc);
         break;
       }
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* 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:
     return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LSQB:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COND_SECT_OPEN;
   case BT_NMSTRT:
   case BT_HEX:
     ptr += MINBPC(enc);
     break;
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   while (HAS_CHAR(enc, ptr, end)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_PERCNT:
       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:
     case BT_HEX:
       ptr += MINBPC(enc);
       break;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 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:
     break;
   case ASCII_X:
     upper = 1;
     break;
   default:
     return 1;
   }
   ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case ASCII_m:
     break;
   case ASCII_M:
     upper = 1;
     break;
   default:
     return 1;
   }
   ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case ASCII_l:
     break;
   case ASCII_L:
     upper = 1;
     break;
   default:
     return 1;
   }
   if (upper)
     return 0;
   *tokPtr = XML_TOK_XML_DECL;
   return 1;
 }
 
 /* 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);
           if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
             *nextTokPtr = ptr + MINBPC(enc);
             return tok;
           }
           break;
         default:
           ptr += MINBPC(enc);
           break;
         }
       }
       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;
       }
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
       if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
         *nextTokPtr = ptr + MINBPC(enc);
         return tok;
       }
       /* fall through */
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 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;
     }
   }
   *nextTokPtr = ptr;
   return XML_TOK_CDATA_SECT_OPEN;
 }
 
 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) {
     size_t n = end - ptr;
     if (n & (MINBPC(enc) - 1)) {
       n &= ~(MINBPC(enc) - 1);
       if (n == 0)
         return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
   switch (BYTE_TYPE(enc, 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;
     }
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_CDATA_SECT_CLOSE;
   case BT_CR:
     ptr += MINBPC(enc);
     REQUIRE_CHAR(enc, ptr, end);
     if (BYTE_TYPE(enc, ptr) == BT_LF)
       ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   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:
     case BT_CR:
     case BT_LF:
     case BT_RSQB:
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   *nextTokPtr = ptr;
   return XML_TOK_DATA_CHARS;
 }
 
 /* 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);
           return XML_TOK_END_TAG;
         default:
           *nextTokPtr = ptr;
           return XML_TOK_INVALID;
         }
       }
       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;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* 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:
     case BT_HEX:
       break;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
     for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
       case BT_HEX:
         break;
       case BT_SEMI:
         *nextTokPtr = ptr + MINBPC(enc);
         return XML_TOK_CHAR_REF;
       default:
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* 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);
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
       break;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
     for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
         break;
       case BT_SEMI:
         *nextTokPtr = ptr + MINBPC(enc);
         return XML_TOK_CHAR_REF;
       default:
         *nextTokPtr = ptr;
         return XML_TOK_INVALID;
       }
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* ptr points to character following "&" */
 
 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:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   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;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* ptr points to character following first character of attribute name */
 
 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;
         return XML_TOK_INVALID;
       }
       hadColon = 1;
       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;
 
         ptr += MINBPC(enc);
         REQUIRE_CHAR(enc, ptr, end);
         t = BYTE_TYPE(enc, ptr);
         if (t == BT_EQUALS)
           break;
         switch (t) {
         case BT_S:
         case BT_LF:
         case BT_CR:
           break;
         default:
           *nextTokPtr = ptr;
           return XML_TOK_INVALID;
         }
       }
       /* 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;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 /* ptr points to character following "<" */
 
 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);
     switch (BYTE_TYPE(enc, ptr)) {
     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;
   case BT_QUEST:
     return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_SOL:
     return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *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;
         return XML_TOK_INVALID;
       }
       hadColon = 1;
       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);
       return XML_TOK_START_TAG_NO_ATTS;
     case BT_SOL:
     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;
       }
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 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) {
     size_t n = end - ptr;
     if (n & (MINBPC(enc) - 1)) {
       n &= ~(MINBPC(enc) - 1);
       if (n == 0)
         return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_LT:
     return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_AMP:
     return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_CR:
     ptr += MINBPC(enc);
     if (! HAS_CHAR(enc, ptr, end))
       return XML_TOK_TRAILING_CR;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
       ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   case BT_RSQB:
     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:
     case BT_LT:
     case BT_NONXML:
     case BT_MALFORM:
     case BT_TRAIL:
     case BT_CR:
     case BT_LF:
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   *nextTokPtr = ptr;
   return XML_TOK_DATA_CHARS;
 }
 
 /* ptr points to character following "%" */
 
 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:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   }
   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;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 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:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return -XML_TOK_POUND_NAME;
 }
 
 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);
       if (t != open)
         break;
       if (! HAS_CHAR(enc, ptr, end))
         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;
       }
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   return XML_TOK_PARTIAL;
 }
 
 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;
   if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
     if (n & (MINBPC(enc) - 1)) {
       n &= ~(MINBPC(enc) - 1);
       if (n == 0)
         return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_QUOT:
     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;
       /* indicate that this might be part of a CR/LF pair */
       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 */
         if (ptr + MINBPC(enc) != end)
           break;
         /* fall through */
       default:
         *nextTokPtr = ptr;
         return XML_TOK_PROLOG_S;
       }
     }
     *nextTokPtr = ptr;
     return XML_TOK_PROLOG_S;
   case BT_PERCNT:
     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_COMMA:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COMMA;
   case BT_LSQB:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_BRACKET;
   case BT_RSQB:
     ptr += MINBPC(enc);
     if (! HAS_CHAR(enc, ptr, end))
       return -XML_TOK_CLOSE_BRACKET;
     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;
       }
     }
     *nextTokPtr = ptr;
     return XML_TOK_CLOSE_BRACKET;
   case BT_LPAR:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_PAREN;
   case BT_RPAR:
     ptr += MINBPC(enc);
     if (! HAS_CHAR(enc, ptr, end))
       return -XML_TOK_CLOSE_PAREN;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_AST:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_ASTERISK;
     case BT_QUEST:
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_QUESTION;
     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;
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_VERBAR:
     *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OR;
   case BT_GT:
     *nextTokPtr = ptr + MINBPC(enc);
     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;
     ptr += MINBPC(enc);
     break;
   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;
   case BT_NONASCII:
     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
       ptr += MINBPC(enc);
       tok = XML_TOK_NAME;
       break;
     }
     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
       ptr += MINBPC(enc);
       tok = XML_TOK_NMTOKEN;
       break;
     }
     /* fall through */
   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_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) {
       case XML_TOK_NAME:
         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;
         }
         break;
       case XML_TOK_PREFIXED_NAME:
         tok = XML_TOK_NMTOKEN;
         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;
       }
       *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_QUESTION;
     default:
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   }
   return -tok;
 }
 
 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;
   else if (! HAS_CHAR(enc, ptr, end)) {
     /* This line cannot be executed.  The incoming data has already
      * been tokenized once, so incomplete characters like this have
      * already been eliminated from the input.  Retaining the paranoia
      * check is still valuable, however.
      */
     return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
   }
   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);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LT:
       /* this is for inside entity references */
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     case BT_LF:
       if (ptr == start) {
         *nextTokPtr = ptr + MINBPC(enc);
         return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
         ptr += MINBPC(enc);
         if (! HAS_CHAR(enc, ptr, end))
           return XML_TOK_TRAILING_CR;
         if (BYTE_TYPE(enc, ptr) == BT_LF)
           ptr += MINBPC(enc);
         *nextTokPtr = ptr;
         return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_S:
       if (ptr == start) {
         *nextTokPtr = ptr + MINBPC(enc);
         return XML_TOK_ATTRIBUTE_VALUE_S;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   *nextTokPtr = ptr;
   return XML_TOK_DATA_CHARS;
 }
 
 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;
   else if (! HAS_CHAR(enc, ptr, end)) {
     /* This line cannot be executed.  The incoming data has already
      * been tokenized once, so incomplete characters like this have
      * already been eliminated from the input.  Retaining the paranoia
      * check is still valuable, however.
      */
     return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
   }
   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);
       *nextTokPtr = 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;
       return XML_TOK_DATA_CHARS;
     case BT_LF:
       if (ptr == start) {
         *nextTokPtr = ptr + MINBPC(enc);
         return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
         ptr += MINBPC(enc);
         if (! HAS_CHAR(enc, ptr, end))
           return XML_TOK_TRAILING_CR;
         if (BYTE_TYPE(enc, ptr) == BT_LF)
           ptr += MINBPC(enc);
         *nextTokPtr = ptr;
         return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   *nextTokPtr = 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;
     if (n & (MINBPC(enc) - 1)) {
       n &= ~(MINBPC(enc) - 1);
       end = ptr + n;
     }
   }
   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);
       if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
         ptr += MINBPC(enc);
         REQUIRE_CHAR(enc, ptr, end);
         if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
           ++level;
           ptr += MINBPC(enc);
         }
       }
       break;
     case BT_RSQB:
       ptr += MINBPC(enc);
       REQUIRE_CHAR(enc, ptr, end);
       if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
         ptr += MINBPC(enc);
         REQUIRE_CHAR(enc, ptr, end);
         if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
           ptr += MINBPC(enc);
           if (level == 0) {
             *nextTokPtr = ptr;
             return XML_TOK_IGNORE_SECT;
           }
           --level;
         }
       }
       break;
     default:
       ptr += MINBPC(enc);
       break;
     }
   }
   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)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
     case BT_HEX:
     case BT_MINUS:
     case BT_APOS:
     case BT_LPAR:
     case BT_RPAR:
     case BT_PLUS:
     case BT_COMMA:
     case BT_SOL:
     case BT_EQUALS:
     case BT_QUEST:
     case BT_CR:
     case BT_LF:
     case BT_SEMI:
     case BT_EXCL:
     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)) {
         *badPtr = ptr;
         return 0;
       }
       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:
       switch (BYTE_TO_ASCII(enc, ptr)) {
       case 0x24: /* $ */
       case 0x40: /* @ */
         break;
       default:
         *badPtr = ptr;
         return 0;
       }
       break;
     }
   }
   return 1;
 }
 
 /* This must only be called for a well-formed start-tag or empty
    element tag.  Returns the number of attributes.  Pointers to the
    first attsMax attributes are stored in atts.
 */
 
 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;
                    initialization just to shut up compilers */
 
   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;
         nAtts++;
       }
       break;
     case BT_APOS:
       if (state != inValue) {
         if (nAtts < attsMax)
           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;
         nAtts++;
       }
       break;
     case BT_AMP:
       if (nAtts < attsMax)
         atts[nAtts].normalized = 0;
       break;
     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)
         state = other;
       else if (state == inValue && nAtts < attsMax)
         atts[nAtts].normalized = 0;
       break;
     case BT_GT:
     case BT_SOL:
       if (state != inValue)
         return nAtts;
       break;
     default:
       break;
     }
   }
   /* not reached */
 }
 
 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;
       }
       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);
       if (result >= 0x110000)
         return -1;
     }
   }
   return checkCharRefNumber(result);
 }
 
 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)) {
       case ASCII_l:
         return ASCII_LT;
       case ASCII_g:
         return ASCII_GT;
       }
     }
     break;
   case 3:
     if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
       ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
         ptr += MINBPC(enc);
         if (CHAR_MATCHES(enc, ptr, ASCII_p))
           return ASCII_AMP;
       }
     }
     break;
   case 4:
     switch (BYTE_TO_ASCII(enc, ptr)) {
     case ASCII_q:
       ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
         ptr += MINBPC(enc);
         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
           ptr += MINBPC(enc);
           if (CHAR_MATCHES(enc, ptr, ASCII_t))
             return ASCII_QUOT;
         }
       }
       break;
     case ASCII_a:
       ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
         ptr += MINBPC(enc);
         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
           ptr += MINBPC(enc);
           if (CHAR_MATCHES(enc, ptr, ASCII_s))
             return ASCII_APOS;
         }
       }
       break;
     }
   }
   return 0;
 }
 
 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
        * been tokenized once, so incomplete characters like this have
        * already been eliminated from the input.  Retaining the
        * paranoia check is still valuable, however.
        */
       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:
     case BT_MINUS:
       ptr += MINBPC(enc);
       break;
     default:
       return (int)(ptr - start);
     }
   }
 }
 
-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:
     case BT_CR:
     case BT_S:
       ptr += MINBPC(enc);
       break;
     default:
       return 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++;
       ptr += MINBPC(enc);
       break;
     case BT_CR:
       pos->lineNumber++;
       ptr += MINBPC(enc);
       if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
         ptr += MINBPC(enc);
       pos->columnNumber = (XML_Size)-1;
       break;
     default:
       ptr += MINBPC(enc);
       break;
     }
     pos->columnNumber++;
   }
 }
 
-#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 */
Index: vendor/expat/dist/lib/xmltok_impl.h
===================================================================
--- vendor/expat/dist/lib/xmltok_impl.h	(revision 355070)
+++ vendor/expat/dist/lib/xmltok_impl.h	(revision 355071)
@@ -1,73 +1,73 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 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>
Index: vendor/expat/dist/lib/xmltok_ns.c
===================================================================
--- vendor/expat/dist/lib/xmltok_ns.c	(revision 355070)
+++ vendor/expat/dist/lib/xmltok_ns.c	(revision 355071)
@@ -1,142 +1,118 @@
 /* This file is included!
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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;
   SET_INIT_ENC_INDEX(p, i);
   p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
   p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
   p->initEnc.updatePosition = initUpdatePosition;
   p->encPtr = encPtr;
   *encPtr = &(p->initEnc);
   return 1;
 }
 
 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;
   XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
   if (ptr != end)
     return 0;
   *p = 0;
   if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
     return enc;
   i = getEncodingIndex(buf);
   if (i == UNKNOWN_ENC)
     return 0;
   return NS(encodings)[i];
 }
 
 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 */
Index: vendor/expat/dist/test-driver-wrapper.sh
===================================================================
--- vendor/expat/dist/test-driver-wrapper.sh	(revision 355070)
+++ vendor/expat/dist/test-driver-wrapper.sh	(revision 355071)
@@ -1,43 +1,43 @@
-#! /bin/bash
+#! /usr/bin/env bash
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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
 top_srcdir="$(dirname "$(type -p "$0")")"
 top_builddir=..
 
 # Suck up all dash-dash test-driver arguments
 test_driver_args=()
 while [[ ${1} != '--' ]]; do
     test_driver_args=( "${test_driver_args[@]}" "${1}" )
     shift
 done
 shift  # drop "--"
 
 exec "${top_srcdir}"/conftools/test-driver "${test_driver_args[@]}" "${top_builddir}"/run.sh "$@"
Index: vendor/expat/dist/tests/Makefile.in
===================================================================
--- vendor/expat/dist/tests/Makefile.in	(revision 355070)
+++ vendor/expat/dist/tests/Makefile.in	(revision 355071)
@@ -1,1219 +1,1249 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 check_PROGRAMS = runtests$(EXEEXT) runtestspp$(EXEEXT)
 TESTS = runtests$(EXEEXT) runtestspp$(EXEEXT)
 subdir = tests
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 LIBRARIES = $(noinst_LIBRARIES)
 ARFLAGS = cru
 AM_V_AR = $(am__v_AR_@AM_V@)
 am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
 am__v_AR_0 = @echo "  AR      " $@;
 am__v_AR_1 = 
 libruntests_a_AR = $(AR) $(ARFLAGS)
 libruntests_a_LIBADD =
 am_libruntests_a_OBJECTS = chardata.$(OBJEXT) structdata.$(OBJEXT) \
 	memcheck.$(OBJEXT) minicheck.$(OBJEXT)
 libruntests_a_OBJECTS = $(am_libruntests_a_OBJECTS)
 am_runtests_OBJECTS = runtests.$(OBJEXT)
 runtests_OBJECTS = $(am_runtests_OBJECTS)
 runtests_DEPENDENCIES = libruntests.a ../lib/libexpat.la
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
 am_runtestspp_OBJECTS = runtestspp.$(OBJEXT)
 runtestspp_OBJECTS = $(am_runtestspp_OBJECTS)
 runtestspp_DEPENDENCIES = libruntests.a ../lib/libexpat.la
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 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)
 LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
 am__v_CC_0 = @echo "  CC      " $@;
 am__v_CC_1 = 
 CCLD = $(CC)
 LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
 	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
 LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CXXFLAGS) $(CXXFLAGS)
 AM_V_CXX = $(am__v_CXX_@AM_V@)
 am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
 am__v_CXX_0 = @echo "  CXX     " $@;
 am__v_CXX_1 = 
 CXXLD = $(CXX)
 CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
 	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
 am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
 am__v_CXXLD_0 = @echo "  CXXLD   " $@;
 am__v_CXXLD_1 = 
 SOURCES = $(libruntests_a_SOURCES) $(runtests_SOURCES) \
 	$(runtestspp_SOURCES)
 DIST_SOURCES = $(libruntests_a_SOURCES) $(runtests_SOURCES) \
 	$(runtestspp_SOURCES)
 RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
 	ctags-recursive dvi-recursive html-recursive info-recursive \
 	install-data-recursive install-dvi-recursive \
 	install-exec-recursive install-html-recursive \
 	install-info-recursive install-pdf-recursive \
 	install-ps-recursive install-recursive installcheck-recursive \
 	installdirs-recursive pdf-recursive ps-recursive \
 	tags-recursive uninstall-recursive
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
   distclean-recursive maintainer-clean-recursive
 am__recursive_targets = \
   $(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
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 am__tty_colors_dummy = \
   mgn= red= grn= lgn= blu= brg= std=; \
   am__color_tests=no
 am__tty_colors = { \
   $(am__tty_colors_dummy); \
   if test "X$(AM_COLOR_TESTS)" = Xno; then \
     am__color_tests=no; \
   elif test "X$(AM_COLOR_TESTS)" = Xalways; then \
     am__color_tests=yes; \
   elif test "X$$TERM" != Xdumb && { test -t 1; } 2>/dev/null; then \
     am__color_tests=yes; \
   fi; \
   if test $$am__color_tests = yes; then \
     red=''; \
     grn=''; \
     lgn=''; \
     blu=''; \
     mgn=''; \
     brg=''; \
     std=''; \
   fi; \
 }
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
     *) f=$$p;; \
   esac;
 am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
 am__install_max = 40
 am__nobase_strip_setup = \
   srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
 am__nobase_strip = \
   for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
 am__nobase_list = $(am__nobase_strip_setup); \
   for p in $$list; do echo "$$p $$p"; done | \
   sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
   $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
     if (++n[$$2] == $(am__install_max)) \
       { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
     END { for (dir in files) print dir, files[dir] }'
 am__base_list = \
   sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
   sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
 am__uninstall_files_from_dir = { \
   test -z "$$files" \
     || { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
     || { echo " ( cd '$$dir' && rm -f" $$files ")"; \
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
 am__recheck_rx = ^[ 	]*:recheck:[ 	]*
 am__global_test_result_rx = ^[ 	]*:global-test-result:[ 	]*
 am__copy_in_global_log_rx = ^[ 	]*:copy-in-global-log:[ 	]*
 # A command that, given a newline-separated list of test names on the
 # standard input, print the name of the tests that are to be re-run
 # upon "make recheck".
 am__list_recheck_tests = $(AWK) '{ \
   recheck = 1; \
   while ((rc = (getline line < ($$0 ".trs"))) != 0) \
     { \
       if (rc < 0) \
         { \
           if ((getline line2 < ($$0 ".log")) < 0) \
 	    recheck = 0; \
           break; \
         } \
       else if (line ~ /$(am__recheck_rx)[nN][Oo]/) \
         { \
           recheck = 0; \
           break; \
         } \
       else if (line ~ /$(am__recheck_rx)[yY][eE][sS]/) \
         { \
           break; \
         } \
     }; \
   if (recheck) \
     print $$0; \
   close ($$0 ".trs"); \
   close ($$0 ".log"); \
 }'
 # A command that, given a newline-separated list of test names on the
 # standard input, create the global log from their .trs and .log files.
 am__create_global_log = $(AWK) ' \
 function fatal(msg) \
 { \
   print "fatal: making $@: " msg | "cat >&2"; \
   exit 1; \
 } \
 function rst_section(header) \
 { \
   print header; \
   len = length(header); \
   for (i = 1; i <= len; i = i + 1) \
     printf "="; \
   printf "\n\n"; \
 } \
 { \
   copy_in_global_log = 1; \
   global_test_result = "RUN"; \
   while ((rc = (getline line < ($$0 ".trs"))) != 0) \
     { \
       if (rc < 0) \
          fatal("failed to read from " $$0 ".trs"); \
       if (line ~ /$(am__global_test_result_rx)/) \
         { \
           sub("$(am__global_test_result_rx)", "", line); \
           sub("[ 	]*$$", "", line); \
           global_test_result = line; \
         } \
       else if (line ~ /$(am__copy_in_global_log_rx)[nN][oO]/) \
         copy_in_global_log = 0; \
     }; \
   if (copy_in_global_log) \
     { \
       rst_section(global_test_result ": " $$0); \
       while ((rc = (getline line < ($$0 ".log"))) != 0) \
       { \
         if (rc < 0) \
           fatal("failed to read from " $$0 ".log"); \
         print line; \
       }; \
       printf "\n"; \
     }; \
   close ($$0 ".trs"); \
   close ($$0 ".log"); \
 }'
 # Restructured Text title.
 am__rst_title = { sed 's/.*/   &   /;h;s/./=/g;p;x;s/ *$$//;p;g' && echo; }
 # Solaris 10 'make', and several other traditional 'make' implementations,
 # pass "-e" to $(SHELL), and POSIX 2008 even requires this.  Work around it
 # by disabling -e (using the XSI extension "set +e") if it's set.
 am__sh_e_setup = case $$- in *e*) set +e;; esac
 # Default flags passed to test drivers.
 am__common_driver_flags = \
   --color-tests "$$am__color_tests" \
   --enable-hard-errors "$$am__enable_hard_errors" \
   --expect-failure "$$am__expect_failure"
 # To be inserted before the command running the test.  Creates the
 # directory for the log if needed.  Stores in $dir the directory
 # containing $f, in $tst the test, in $log the log.  Executes the
 # developer- defined test setup AM_TESTS_ENVIRONMENT (if any), and
 # passes TESTS_ENVIRONMENT.  Set up options for the wrapper that
 # will run the test scripts (or their associated LOG_COMPILER, if
 # thy have one).
 am__check_pre = \
 $(am__sh_e_setup);					\
 $(am__vpath_adj_setup) $(am__vpath_adj)			\
 $(am__tty_colors);					\
 srcdir=$(srcdir); export srcdir;			\
 case "$@" in						\
   */*) am__odir=`echo "./$@" | sed 's|/[^/]*$$||'`;;	\
     *) am__odir=.;; 					\
 esac;							\
 test "x$$am__odir" = x"." || test -d "$$am__odir" 	\
   || $(MKDIR_P) "$$am__odir" || exit $$?;		\
 if test -f "./$$f"; then dir=./;			\
 elif test -f "$$f"; then dir=;				\
 else dir="$(srcdir)/"; fi;				\
 tst=$$dir$$f; log='$@'; 				\
 if test -n '$(DISABLE_HARD_ERRORS)'; then		\
   am__enable_hard_errors=no; 				\
 else							\
   am__enable_hard_errors=yes; 				\
 fi; 							\
 case " $(XFAIL_TESTS) " in				\
   *[\ \	]$$f[\ \	]* | *[\ \	]$$dir$$f[\ \	]*) \
     am__expect_failure=yes;;				\
   *)							\
     am__expect_failure=no;;				\
 esac; 							\
 $(AM_TESTS_ENVIRONMENT) $(TESTS_ENVIRONMENT)
 # A shell command to get the names of the tests scripts with any registered
 # extension removed (i.e., equivalently, the names of the test logs, with
 # the '.log' extension removed).  The result is saved in the shell variable
 # '$bases'.  This honors runtime overriding of TESTS and TEST_LOGS.  Sadly,
 # we cannot use something simpler, involving e.g., "$(TEST_LOGS:.log=)",
 # since that might cause problem with VPATH rewrites for suffix-less tests.
 # See also 'test-harness-vpath-rewrite.sh' and 'test-trs-basic.sh'.
 am__set_TESTS_bases = \
   bases='$(TEST_LOGS)'; \
   bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
   bases=`echo $$bases`
 RECHECK_LOGS = $(TEST_LOGS)
 TEST_SUITE_LOG = test-suite.log
 TEST_EXTENSIONS = @EXEEXT@ .test
 LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
 am__set_b = \
   case '$@' in \
     */*) \
       case '$*' in \
         */*) b='$*';; \
           *) b=`echo '$@' | sed 's/\.log$$//'`; \
        esac;; \
     *) \
       b='$*';; \
   esac
 am__test_logs1 = $(TESTS:=.log)
 am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
 TEST_LOGS = $(am__test_logs2:.test.log=.log)
 TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/conftools/test-driver
 TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
 	$(TEST_LOG_FLAGS)
 DIST_SUBDIRS = $(SUBDIRS)
 am__DIST_COMMON = $(srcdir)/Makefile.in \
 	$(top_srcdir)/conftools/depcomp \
 	$(top_srcdir)/conftools/test-driver
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 am__relativize = \
   dir0=`pwd`; \
   sed_first='s,^\([^/]*\)/.*$$,\1,'; \
   sed_rest='s,^[^/]*/*,,'; \
   sed_last='s,^.*/\([^/]*\)$$,\1,'; \
   sed_butlast='s,/*[^/]*$$,,'; \
   while test -n "$$dir1"; do \
     first=`echo "$$dir1" | sed -e "$$sed_first"`; \
     if test "$$first" != "."; then \
       if test "$$first" = ".."; then \
         dir2=`echo "$$dir0" | sed -e "$$sed_last"`/"$$dir2"; \
         dir0=`echo "$$dir0" | sed -e "$$sed_butlast"`; \
       else \
         first2=`echo "$$dir2" | sed -e "$$sed_first"`; \
         if test "$$first2" = "$$first"; then \
           dir2=`echo "$$dir2" | sed -e "$$sed_rest"`; \
         else \
           dir2="../$$dir2"; \
         fi; \
         dir0="$$dir0"/"$$first"; \
       fi; \
     fi; \
     dir1=`echo "$$dir1" | sed -e "$$sed_rest"`; \
   done; \
   reldir="$$dir2"
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 SUBDIRS = . benchmark
 AM_CPPFLAGS = -I$(srcdir)/../lib
 noinst_LIBRARIES = libruntests.a
 
 # To support MinGW and Non-MinGW at the same time:
 LOG_DRIVER = $(srcdir)/../test-driver-wrapper.sh
 libruntests_a_SOURCES = \
     chardata.c \
     structdata.c \
     memcheck.c \
     minicheck.c
 
 runtests_SOURCES = \
     runtests.c
 
 runtestspp_SOURCES = \
     runtestspp.cpp
 
 runtests_LDADD = libruntests.a ../lib/libexpat.la
 runtestspp_LDADD = libruntests.a ../lib/libexpat.la
 EXTRA_DIST = \
     chardata.h \
     structdata.h \
     minicheck.h \
     memcheck.h \
     README.txt \
     udiffer.py \
     xmltest.log.expected \
     xmltest.sh
 
 all: all-recursive
 
 .SUFFIXES:
 .SUFFIXES: .c .cpp .lo .log .o .obj .test .test$(EXEEXT) .trs
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu tests/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(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; \
 	rm -f $$list || exit $$?; \
 	test -n "$(EXEEXT)" || exit 0; \
 	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
 	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)
 
 runtestspp$(EXEEXT): $(runtestspp_OBJECTS) $(runtestspp_DEPENDENCIES) $(EXTRA_runtestspp_DEPENDENCIES) 
 	@rm -f runtestspp$(EXEEXT)
 	$(AM_V_CXXLD)$(CXXLINK) $(runtestspp_OBJECTS) $(runtestspp_LDADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 
 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 $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
 
 .c.obj:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .c.lo:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
 .cpp.o:
 @am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
 
 .cpp.obj:
 @am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .cpp.lo:
 @am__fastdepCXX_TRUE@	$(AM_V_CXX)$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 
 # This directory's subdirectories are mostly independent; you can cd
 # into them and run 'make' without going through this Makefile.
 # To change the values of 'make' variables: instead of editing Makefiles,
 # (1) if the variable is set in 'config.status', edit 'config.status'
 #     (which will cause the Makefiles to be regenerated when you run 'make');
 # (2) otherwise, pass the desired values on the 'make' command line.
 $(am__recursive_targets):
 	@fail=; \
 	if $(am__make_keepgoing); then \
 	  failcom='fail=yes'; \
 	else \
 	  failcom='exit 1'; \
 	fi; \
 	dot_seen=no; \
 	target=`echo $@ | sed s/-recursive//`; \
 	case "$@" in \
 	  distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
 	  *) list='$(SUBDIRS)' ;; \
 	esac; \
 	for subdir in $$list; do \
 	  echo "Making $$target in $$subdir"; \
 	  if test "$$subdir" = "."; then \
 	    dot_seen=yes; \
 	    local_target="$$target-am"; \
 	  else \
 	    local_target="$$target"; \
 	  fi; \
 	  ($(am__cd) $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
 	  || eval $$failcom; \
 	done; \
 	if test "$$dot_seen" = "no"; then \
 	  $(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
 	fi; test -z "$$fail"
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-recursive
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
 	  include_option=--etags-include; \
 	  empty_fix=.; \
 	else \
 	  include_option=--include; \
 	  empty_fix=; \
 	fi; \
 	list='$(SUBDIRS)'; for subdir in $$list; do \
 	  if test "$$subdir" = .; then :; else \
 	    test ! -f $$subdir/TAGS || \
 	      set "$$@" "$$include_option=$$here/$$subdir/TAGS"; \
 	  fi; \
 	done; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-recursive
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscopelist: cscopelist-recursive
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.files
 
 distclean-tags:
 	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
 
 # Recover from deleted '.trs' file; this should ensure that
 # "rm -f foo.log; make foo.trs" re-run 'foo.test', and re-create
 # both 'foo.log' and 'foo.trs'.  Break the recipe in two subshells
 # to avoid problems with "make -n".
 .log.trs:
 	rm -f $< $@
 	$(MAKE) $(AM_MAKEFLAGS) $<
 
 # Leading 'am--fnord' is there to ensure the list of targets does not
 # expand to empty, as could happen e.g. with make check TESTS=''.
 am--fnord $(TEST_LOGS) $(TEST_LOGS:.log=.trs): $(am__force_recheck)
 am--force-recheck:
 	@:
 
 $(TEST_SUITE_LOG): $(TEST_LOGS)
 	@$(am__set_TESTS_bases); \
 	am__f_ok () { test -f "$$1" && test -r "$$1"; }; \
 	redo_bases=`for i in $$bases; do \
 	              am__f_ok $$i.trs && am__f_ok $$i.log || echo $$i; \
 	            done`; \
 	if test -n "$$redo_bases"; then \
 	  redo_logs=`for i in $$redo_bases; do echo $$i.log; done`; \
 	  redo_results=`for i in $$redo_bases; do echo $$i.trs; done`; \
 	  if $(am__make_dryrun); then :; else \
 	    rm -f $$redo_logs && rm -f $$redo_results || exit 1; \
 	  fi; \
 	fi; \
 	if test -n "$$am__remaking_logs"; then \
 	  echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
 	       "recursion detected" >&2; \
 	elif test -n "$$redo_logs"; then \
 	  am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
 	fi; \
 	if $(am__make_dryrun); then :; else \
 	  st=0;  \
 	  errmsg="fatal: making $(TEST_SUITE_LOG): failed to create"; \
 	  for i in $$redo_bases; do \
 	    test -f $$i.trs && test -r $$i.trs \
 	      || { echo "$$errmsg $$i.trs" >&2; st=1; }; \
 	    test -f $$i.log && test -r $$i.log \
 	      || { echo "$$errmsg $$i.log" >&2; st=1; }; \
 	  done; \
 	  test $$st -eq 0 || exit 1; \
 	fi
 	@$(am__sh_e_setup); $(am__tty_colors); $(am__set_TESTS_bases); \
 	ws='[ 	]'; \
 	results=`for b in $$bases; do echo $$b.trs; done`; \
 	test -n "$$results" || results=/dev/null; \
 	all=`  grep "^$$ws*:test-result:"           $$results | wc -l`; \
 	pass=` grep "^$$ws*:test-result:$$ws*PASS"  $$results | wc -l`; \
 	fail=` grep "^$$ws*:test-result:$$ws*FAIL"  $$results | wc -l`; \
 	skip=` grep "^$$ws*:test-result:$$ws*SKIP"  $$results | wc -l`; \
 	xfail=`grep "^$$ws*:test-result:$$ws*XFAIL" $$results | wc -l`; \
 	xpass=`grep "^$$ws*:test-result:$$ws*XPASS" $$results | wc -l`; \
 	error=`grep "^$$ws*:test-result:$$ws*ERROR" $$results | wc -l`; \
 	if test `expr $$fail + $$xpass + $$error` -eq 0; then \
 	  success=true; \
 	else \
 	  success=false; \
 	fi; \
 	br='==================='; br=$$br$$br$$br$$br; \
 	result_count () \
 	{ \
 	    if test x"$$1" = x"--maybe-color"; then \
 	      maybe_colorize=yes; \
 	    elif test x"$$1" = x"--no-color"; then \
 	      maybe_colorize=no; \
 	    else \
 	      echo "$@: invalid 'result_count' usage" >&2; exit 4; \
 	    fi; \
 	    shift; \
 	    desc=$$1 count=$$2; \
 	    if test $$maybe_colorize = yes && test $$count -gt 0; then \
 	      color_start=$$3 color_end=$$std; \
 	    else \
 	      color_start= color_end=; \
 	    fi; \
 	    echo "$${color_start}# $$desc $$count$${color_end}"; \
 	}; \
 	create_testsuite_report () \
 	{ \
 	  result_count $$1 "TOTAL:" $$all   "$$brg"; \
 	  result_count $$1 "PASS: " $$pass  "$$grn"; \
 	  result_count $$1 "SKIP: " $$skip  "$$blu"; \
 	  result_count $$1 "XFAIL:" $$xfail "$$lgn"; \
 	  result_count $$1 "FAIL: " $$fail  "$$red"; \
 	  result_count $$1 "XPASS:" $$xpass "$$red"; \
 	  result_count $$1 "ERROR:" $$error "$$mgn"; \
 	}; \
 	{								\
 	  echo "$(PACKAGE_STRING): $(subdir)/$(TEST_SUITE_LOG)" |	\
 	    $(am__rst_title);						\
 	  create_testsuite_report --no-color;				\
 	  echo;								\
 	  echo ".. contents:: :depth: 2";				\
 	  echo;								\
 	  for b in $$bases; do echo $$b; done				\
 	    | $(am__create_global_log);					\
 	} >$(TEST_SUITE_LOG).tmp || exit 1;				\
 	mv $(TEST_SUITE_LOG).tmp $(TEST_SUITE_LOG);			\
 	if $$success; then						\
 	  col="$$grn";							\
 	 else								\
 	  col="$$red";							\
 	  test x"$$VERBOSE" = x || cat $(TEST_SUITE_LOG);		\
 	fi;								\
 	echo "$${col}$$br$${std}"; 					\
 	echo "$${col}Testsuite summary for $(PACKAGE_STRING)$${std}";	\
 	echo "$${col}$$br$${std}"; 					\
 	create_testsuite_report --maybe-color;				\
 	echo "$$col$$br$$std";						\
 	if $$success; then :; else					\
 	  echo "$${col}See $(subdir)/$(TEST_SUITE_LOG)$${std}";		\
 	  if test -n "$(PACKAGE_BUGREPORT)"; then			\
 	    echo "$${col}Please report to $(PACKAGE_BUGREPORT)$${std}";	\
 	  fi;								\
 	  echo "$$col$$br$$std";					\
 	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)
 	@set +e; $(am__set_TESTS_bases); \
 	log_list=`for i in $$bases; do echo $$i.log; done`; \
 	trs_list=`for i in $$bases; do echo $$i.trs; done`; \
 	log_list=`echo $$log_list`; trs_list=`echo $$trs_list`; \
 	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) TEST_LOGS="$$log_list"; \
 	exit $$?;
 recheck: all $(check_PROGRAMS)
 	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
 	@set +e; $(am__set_TESTS_bases); \
 	bases=`for i in $$bases; do echo $$i; done \
 	         | $(am__list_recheck_tests)` || exit 1; \
 	log_list=`for i in $$bases; do echo $$i.log; done`; \
 	log_list=`echo $$log_list`; \
 	$(MAKE) $(AM_MAKEFLAGS) $(TEST_SUITE_LOG) \
 	        am__force_recheck=am--force-recheck \
 	        TEST_LOGS="$$log_list"; \
 	exit $$?
 runtests.log: runtests$(EXEEXT)
 	@p='runtests$(EXEEXT)'; \
 	b='runtests'; \
 	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
 runtestspp.log: runtestspp$(EXEEXT)
 	@p='runtestspp$(EXEEXT)'; \
 	b='runtestspp'; \
 	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
 .test.log:
 	@p='$<'; \
 	$(am__set_b); \
 	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
 @am__EXEEXT_TRUE@.test$(EXEEXT).log:
 @am__EXEEXT_TRUE@	@p='$<'; \
 @am__EXEEXT_TRUE@	$(am__set_b); \
 @am__EXEEXT_TRUE@	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
 @am__EXEEXT_TRUE@	--log-file $$b.log --trs-file $$b.trs \
 @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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 	@list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
 	  if test "$$subdir" = .; then :; else \
 	    $(am__make_dryrun) \
 	      || test -d "$(distdir)/$$subdir" \
 	      || $(MKDIR_P) "$(distdir)/$$subdir" \
 	      || exit 1; \
 	    dir1=$$subdir; dir2="$(distdir)/$$subdir"; \
 	    $(am__relativize); \
 	    new_distdir=$$reldir; \
 	    dir1=$$subdir; dir2="$(top_distdir)"; \
 	    $(am__relativize); \
 	    new_top_distdir=$$reldir; \
 	    echo " (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) top_distdir="$$new_top_distdir" distdir="$$new_distdir" \\"; \
 	    echo "     am__remove_distdir=: am__skip_length_check=: am__skip_mode_fix=: distdir)"; \
 	    ($(am__cd) $$subdir && \
 	      $(MAKE) $(AM_MAKEFLAGS) \
 	        top_distdir="$$new_top_distdir" \
 	        distdir="$$new_distdir" \
 		am__remove_distdir=: \
 		am__skip_length_check=: \
 		am__skip_mode_fix=: \
 	        distdir) \
 	      || exit 1; \
 	  fi; \
 	done
 check-am: all-am
 	$(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS)
 	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
 check: check-recursive
 all-am: Makefile $(LIBRARIES)
 installdirs: installdirs-recursive
 installdirs-am:
 install: install-recursive
 install-exec: install-exec-recursive
 install-data: install-data-recursive
 uninstall: uninstall-recursive
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-recursive
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 	-test -z "$(TEST_LOGS)" || rm -f $(TEST_LOGS)
 	-test -z "$(TEST_LOGS:.log=.trs)" || rm -f $(TEST_LOGS:.log=.trs)
 	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-recursive
 
 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
 
 dvi: dvi-recursive
 
 dvi-am:
 
 html: html-recursive
 
 html-am:
 
 info: info-recursive
 
 info-am:
 
 install-data-am:
 
 install-dvi: install-dvi-recursive
 
 install-dvi-am:
 
 install-exec-am:
 
 install-html: install-html-recursive
 
 install-html-am:
 
 install-info: install-info-recursive
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-recursive
 
 install-pdf-am:
 
 install-ps: install-ps-recursive
 
 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
 
 mostlyclean: mostlyclean-recursive
 
 mostlyclean-am: mostlyclean-compile mostlyclean-generic \
 	mostlyclean-libtool
 
 pdf: pdf-recursive
 
 pdf-am:
 
 ps: ps-recursive
 
 ps-am:
 
 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
 
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/tests/benchmark/Makefile.in
===================================================================
--- vendor/expat/dist/tests/benchmark/Makefile.in	(revision 355070)
+++ vendor/expat/dist/tests/benchmark/Makefile.in	(revision 355071)
@@ -1,629 +1,646 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 noinst_PROGRAMS = benchmark$(EXEEXT)
 subdir = tests/benchmark
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 PROGRAMS = $(noinst_PROGRAMS)
 am_benchmark_OBJECTS = benchmark.$(OBJEXT)
 benchmark_OBJECTS = $(am_benchmark_OBJECTS)
 benchmark_DEPENDENCIES = ../../lib/libexpat.la
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 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)
 LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
 am__v_CC_0 = @echo "  CC      " $@;
 am__v_CC_1 = 
 CCLD = $(CC)
 LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 SOURCES = $(benchmark_SOURCES)
 DIST_SOURCES = $(benchmark_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 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
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 am__DIST_COMMON = $(srcdir)/Makefile.in \
 	$(top_srcdir)/conftools/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 AM_CPPFLAGS = -I$(srcdir)/../../lib
 benchmark_SOURCES = benchmark.c
 benchmark_LDADD = ../../lib/libexpat.la
 EXTRA_DIST = \
     README.txt
 
 all: all-am
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .o .obj
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu tests/benchmark/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu tests/benchmark/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 
 clean-noinstPROGRAMS:
 	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
 	echo " rm -f" $$list; \
 	rm -f $$list || exit $$?; \
 	test -n "$(EXEEXT)" || exit 0; \
 	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
 	echo " rm -f" $$list; \
 	rm -f $$list
 
 benchmark$(EXEEXT): $(benchmark_OBJECTS) $(benchmark_DEPENDENCIES) $(EXTRA_benchmark_DEPENDENCIES) 
 	@rm -f benchmark$(EXEEXT)
 	$(AM_V_CCLD)$(LINK) $(benchmark_OBJECTS) $(benchmark_LDADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 
 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 $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
 
 .c.obj:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .c.lo:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-am
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-am
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscopelist: cscopelist-am
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 check-am: all-am
 check: check-am
 all-am: Makefile $(PROGRAMS)
 installdirs:
 install: install-am
 install-exec: install-exec-am
 install-data: install-data-am
 uninstall: uninstall-am
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-am
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 clean: clean-am
 
 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
 
 dvi: dvi-am
 
 dvi-am:
 
 html: html-am
 
 html-am:
 
 info: info-am
 
 info-am:
 
 install-data-am:
 
 install-dvi: install-dvi-am
 
 install-dvi-am:
 
 install-exec-am:
 
 install-html: install-html-am
 
 install-html-am:
 
 install-info: install-info-am
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-am
 
 install-pdf-am:
 
 install-ps: install-ps-am
 
 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
 
 mostlyclean: mostlyclean-am
 
 mostlyclean-am: mostlyclean-compile mostlyclean-generic \
 	mostlyclean-libtool
 
 pdf: pdf-am
 
 pdf-am:
 
 ps: ps-am
 
 ps-am:
 
 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 \
 	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 maintainer-clean \
 	maintainer-clean-generic mostlyclean mostlyclean-compile \
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	tags tags-am uninstall uninstall-am
 
 .PRECIOUS: Makefile
 
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/tests/benchmark/benchmark.c
===================================================================
--- vendor/expat/dist/tests/benchmark/benchmark.c	(revision 355070)
+++ vendor/expat/dist/tests/benchmark/benchmark.c	(revision 355071)
@@ -1,149 +1,145 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #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);
     }
   }
 
   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
     parser = XML_ParserCreate(NULL);
 
   i = 0;
   XMLBufEnd = XMLBuf + fileSize;
   while (i < nrOfLoops) {
     XMLBufPtr = XMLBuf;
     isFinal = 0;
     tstart = clock();
     do {
       int parseBufferSize = XMLBufEnd - XMLBufPtr;
       if (parseBufferSize <= bufferSize)
         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;
 }
Index: vendor/expat/dist/tests/chardata.c
===================================================================
--- vendor/expat/dist/tests/chardata.c	(revision 355070)
+++ vendor/expat/dist/tests/chardata.c	(revision 355071)
@@ -1,105 +1,98 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef HAVE_EXPAT_CONFIG_H
-# include <expat_config.h>
+#  include <expat_config.h>
 #endif
 #include "minicheck.h"
 
 #include <assert.h>
 #include <stdio.h>
 #include <string.h>
 
 #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;
 }
Index: vendor/expat/dist/tests/chardata.h
===================================================================
--- vendor/expat/dist/tests/chardata.h	(revision 355070)
+++ vendor/expat/dist/tests/chardata.h	(revision 355071)
@@ -1,63 +1,60 @@
 /* Interface to some helper routines used to accumulate and check text
    and attribute content.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifndef XML_CHARDATA_H
-#define XML_CHARDATA_H 1
+#  define XML_CHARDATA_H 1
 
-#ifndef XML_VERSION
-#include "expat.h"                      /* need XML_Char */
-#endif
+#  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
 }
 #endif
Index: vendor/expat/dist/tests/memcheck.c
===================================================================
--- vendor/expat/dist/tests/memcheck.c	(revision 355070)
+++ vendor/expat/dist/tests/memcheck.c	(revision 355071)
@@ -1,198 +1,190 @@
 /* Debug allocators for the Expat test suite
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <stdio.h>
 #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;
 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));
+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;
+  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;
-    }
+  /* 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;
+  return entry->allocation;
 }
 
 static AllocationEntry *
-find_allocation(void *ptr)
-{
-    AllocationEntry *entry;
+find_allocation(void *ptr) {
+  AllocationEntry *entry;
 
-    for (entry = alloc_head; entry != NULL; entry = entry->next) {
-        if (entry->allocation == ptr) {
-            return 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;
+tracking_free(void *ptr) {
+  AllocationEntry *entry;
 
-    if (ptr == NULL) {
-        /* There won't be an entry for this */
-        return;
-    }
+  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);
+  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 (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;
+  }
+
+  /* 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;
+tracking_report(void) {
+  AllocationEntry *entry;
 
-    if (alloc_head == NULL)
-        return 1;
+  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;
+  /* 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;
 }
Index: vendor/expat/dist/tests/memcheck.h
===================================================================
--- vendor/expat/dist/tests/memcheck.h	(revision 355070)
+++ vendor/expat/dist/tests/memcheck.h	(revision 355071)
@@ -1,57 +1,57 @@
 /* Interface to allocation functions that will track what has or has
    not been freed.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 #ifndef XML_MEMCHECK_H
-#define XML_MEMCHECK_H 1
+#  define XML_MEMCHECK_H 1
 
 /* Allocation declarations */
 
 void *tracking_malloc(size_t size);
 void tracking_free(void *ptr);
 void *tracking_realloc(void *ptr, size_t size);
 
 /* End-of-test check to see if unfreed allocations remain. Returns
  * TRUE (1) if there is nothing, otherwise prints a report of the
  * remaining allocations and returns FALSE (0).
  */
 int tracking_report(void);
 
 #endif /* XML_MEMCHECK_H */
 
 #ifdef __cplusplus
 }
 #endif
Index: vendor/expat/dist/tests/minicheck.c
===================================================================
--- vendor/expat/dist/tests/minicheck.c	(revision 355070)
+++ vendor/expat/dist/tests/minicheck.c	(revision 355071)
@@ -1,242 +1,229 @@
 /* Miniature re-implementation of the "check" library.
 
    This is intended to support just enough of check to run the Expat
    tests.  This interface is based entirely on the portion of the
    check library being used.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <setjmp.h>
 #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);
+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;
+  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;
-    }
+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);
+  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;
 
 static char const *_check_current_function = NULL;
 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++;
+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->setup();
-            }
-            /* test */
-            if (setjmp(env)) {
-                add_failure(runner, verbosity);
-                continue;
-            }
-            (tc->tests[i])();
+      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();
-            }
+      /* teardown */
+      if (tc->teardown != NULL) {
+        if (setjmp(env)) {
+          add_failure(runner, verbosity);
+          continue;
         }
-        tc = tc->next_tcase;
+        tc->teardown();
+      }
     }
-    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 = 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);
 }
Index: vendor/expat/dist/tests/minicheck.h
===================================================================
--- vendor/expat/dist/tests/minicheck.h	(revision 355070)
+++ vendor/expat/dist/tests/minicheck.h	(revision 355071)
@@ -1,119 +1,119 @@
 /* Miniature re-implementation of the "check" library.
 
    This is intended to support just enough of check to run the Expat
    tests.  This interface is based entirely on the portion of the
    check library being used.
 
    This is *source* compatible, but not necessary *link* compatible.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef __cplusplus
 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);
 typedef void (*tcase_test_function)(void);
 
 typedef struct SRunner SRunner;
 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.
  */
 
 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);
 void srunner_run_all(SRunner *runner, int verbosity);
 int srunner_ntests_failed(SRunner *runner);
 void srunner_free(SRunner *runner);
 
 #ifdef __cplusplus
 }
 #endif
Index: vendor/expat/dist/tests/runtests.c
===================================================================
--- vendor/expat/dist/tests/runtests.c	(revision 355070)
+++ vendor/expat/dist/tests/runtests.c	(revision 355071)
@@ -1,12371 +1,11597 @@
 /* Run the Expat test suite
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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 */
+#  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 XML_Parser 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;
    this should be used when the parser reports an error we weren't
    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;
+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;
 
-    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++;
+  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;
+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;
     }
-    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;
+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;
 
-    /* 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;
-    }
+  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
 
 /* Regression test for SF bug #600479.
    XXX There should be a test that exercises all legal XML Unicode
    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
 
 /* Regression test for SF bug #477667.
    This test assures that any 8-bit character followed by a 7-bit
    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 */
+#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;
-    };
+START_TEST(test_utf8_auto_align) {
+  struct TestCase {
+    ptrdiff_t expectedMovementInChars;
+    const char *input;
+  };
 
-    struct TestCase cases[] = {
-        {00, ""},
+  struct TestCase cases[] = {
+      {00, ""},
 
-        {00, UTF8_LEAD_1},
+      {00, UTF8_LEAD_1},
 
-        {-1, UTF8_LEAD_2},
-        {00, UTF8_LEAD_2 UTF8_FOLLOW},
+      {-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_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},
-    };
+      {-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;
+  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);
+    _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");
-        }
+    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");
-    }
+  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"
+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"
         "\000<\000d\000o\000c\000 \000a\000=\000'\0001\0002\0003\000'\000>"
         "\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 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);
+  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 */
+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);
-    }
+  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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "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")
         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("\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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "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")
         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("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;
+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);
-    }
+  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;
+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);
-    }
+  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
 
 #define STRUCT_START_TAG 0
 #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;
+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_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);
+  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");
+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(parser);
-    if (lineno != 3) {
-        char buffer[100];
-        sprintf(buffer, "expected 3 lines, saw %" XML_FMT_INT_MOD "u", lineno);
-        fail(buffer);
-    }
+  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");
+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(parser);
-    if (colno != 4) { 
-        char buffer[100];
-        sprintf(buffer, 
-            "expected 4 columns, saw %" XML_FMT_INT_MOD "u", colno);
-        fail(buffer);
-    }
+  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: */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "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-+"
         /* until we have at least 1024 characters on the line: */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-+"
         "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.
  */
 
 /* Helpers used by the following test; this checks any "attr" and "refs"
    attributes to make sure whitespace has been normalized.
 
    Return true if whitespace has been normalized in a string, using
    the rules for attribute value normalization.  The 'is_cdata' flag
    is needed since CDATA attributes don't need to have multiple
    whitespace characters collapsed to a single space, while other
    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"
         "            refs IDREFS   #REQUIRED>\n"
         "]>\n"
         "<doc attr='    a  b c\t\td\te\t' refs=' id-1   \t  id-2\t\t'  \n"
         "     ents=' ent-1   \t\r\n"
         "            ent-2  ' >\n"
         "  <e id='id-1'/>\n"
         "  <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;
+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;
 
-    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;
+  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
-    };
+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);
+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);
 
-    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);
+  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;
+  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
-    };
+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");
+  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
-    };
+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");
+  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
 
 /* Test that no error is reported for unknown entities if we don't
    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
 
 /* Test that an error is reported for unknown entities if we don't
    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
 
 /* Test that an error is reported for unknown entities if we don't
    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
 
 /* Test that an error is reported for unknown entities if we have read
    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
 
 /* Test that external entity handling is not done if the parsing flag
  * 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
 
 /* Test that no error is reported for unknown entities if we have read
    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;
+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);
-    }
+  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/>";
+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/>"));
+  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;
+                            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");
+  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"),
+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;
+          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);
-    }
+  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
 
 /* See related SF bug #673791.
    When namespace processing is enabled, setting the namespace URI for
    a prefix is not allowed; this test ensures that it *is* allowed
    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
 
 /* Regression test for SF bug #824420.
    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/>";
+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);
+  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 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;
+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");
+  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;
+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_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(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(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(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");
+  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>");
 
-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);
 
-    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(g_parser, text, (int)strlen(text), XML_TRUE)
+      == XML_STATUS_ERROR)
+    xml_failure(g_parser);
+  CharData_CheckXMLChars(&storage, expected);
 
-    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(g_parser, NULL);
+  CharData_Init(&storage);
+  XML_SetUserData(g_parser, &storage);
+  XML_SetCharacterDataHandler(g_parser, accumulate_characters);
+  XML_SetDefaultHandler(g_parser, dummy_default_handler);
 
-    /* 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);
+  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");
+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);
+  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
 
 /* Test UTF16 conversion of a long cdata string */
 
 /* 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
         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
         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
         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
         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
         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")
         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("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(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);
+  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;
+  };
 
-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},
 
-    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><![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><!<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}};
 
-        {"<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);
 
-    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);
 
-        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(parser, NULL);
+    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
 
 /* 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;
-    };
+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;
+  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;
+  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];
+    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(parser, NULL);
+      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>";
+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;
+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);
+  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;
+START_TEST(test_memory_allocation) {
+  char *buffer = (char *)XML_MemMalloc(g_parser, 256);
+  char *p;
 
-    if (buffer == NULL) {
-        fail("Allocation failed");
+  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;
+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"));
+  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(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"));
+  /* 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(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"));
+  /* 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(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"));
+  /* 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(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"));
+  /* 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(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"));
+  /* 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
-    };
+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);
+  /* 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(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");
+  /* 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(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  /* 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
-    };
+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);
+  /* 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(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");
+  /* 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(parser, text2, (int)strlen(text2),
-                                XML_TRUE) == XML_STATUS_ERROR)
-        xml_failure(parser);
+  /* 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;
+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++;
+  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 (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;
+    if (attr->name == NULL) {
+      fail("Attribute not recognised");
+      return;
     }
-    id = XML_GetIdAttributeIndex(parser);
-    if (id == -1 && info->id_name != NULL) {
-        fail("ID not present");
-        return;
+    if (xcstrcmp(atts[1], attr->value)) {
+      fail("Attribute has wrong value");
+      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;
-    }
+    /* 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;
+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);
+  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;
+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");
+  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>";
+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);
+  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;
+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;
 
-    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;
+  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;
+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;
 
-    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;
+  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;
+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;
 
-    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");
-    }
+  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);
+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);
 
-    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);
+  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;
+  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;
+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);
-    }
+  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>";
+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");
+  /* 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;
+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;
+  /* 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;
+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);
+  /* 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(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");
+  /* 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;
+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;
 
-    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;
+  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;
+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;
 
-    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;
+  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;
+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);
+  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(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");
+  /* 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;
+rsqb_handler(void *userData, const XML_Char *s, int len) {
+  int *pfound = (int *)userData;
 
-    if (len == 1 && *s == XCS(']'))
-        *pfound = 1;
+  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);
+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");
+  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(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");
+  /* 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(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");
+  /* 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;
+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;
 
-    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;
+  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;
+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");
+  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;
+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;
 
-    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);
+  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);
+  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;
+  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>";
+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);
+  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
 
 /* Test user parameter settings */
 /* Variable holding the expected handler userData */
 static void *handler_data = NULL;
 /* Count of the number of times the comment handler has been invoked */
 static int comment_count = 0;
 /* Count of the number of skipped entities */
 static int skip_count = 0;
 /* Count of the number of times the XML declaration handler is invoked */
 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;
+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;
 
-    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;
+  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>";
+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");
+  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
 
 /* Test that an explicit external entity handler argument replaces
  * the parser as the first argument.
  *
  * We do not call the first parameter to the external entity handler
  * 'parser' for once, since the first time the handler is called it
  * will actually be a text string.  We need to be able to access the
  * global 'parser' variable to create our external entity parser from,
  * 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;
+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;
 
-    if ((void *)parameter != handler_data)
-        fail("External entity ref handler parameter not correct");
+  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(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);
+  /* 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;
+  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>";
+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);
+  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(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);
+  /* 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>";
+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");
+  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(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 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(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");
+  /* 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
  * of the pool allocation code in the parser that otherwise does not
  * 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;
+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");
+  /* 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(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 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(parser, INT_MAX - (context_bytes + 1025)) != 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(parser, 1000) == NULL)
-        fail("1000 buffer 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
 #undef POST_ERROR_STR
 
 /* 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;
+  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");
+  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;
+#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");
+  /* 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(parser, byte_character_handler);
-    XML_SetUserData(parser, &data);
-    if (XML_Parse(parser, text, (int)strlen(text), XML_TRUE) != XML_STATUS_OK)
-        xml_failure(parser);
+  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
 #undef CDATA_TEXT
 #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;
+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);
+  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(parser, NULL);
-    run_character_check(text, result);
+  /* Now try again and check the translation */
+  XML_ParserReset(g_parser, NULL);
+  run_character_check(text, result);
 }
 END_TEST
 
 /* Regression test that an invalid tag in an external parameter
  * reference in an external DTD is correctly faulted.
  *
  * Only a few specific tags are legal in DTDs ignoring comments and
  * processing instructions, all of which begin with an exclamation
  * mark.  "<el/>" is not one of them, so the parser should raise an
  * 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;
+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;
 
-    if (systemId == NULL)
-        return XML_STATUS_OK;
+  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");
+  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");
-    }
+  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;
+  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;
+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++;
-    }
+  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;
+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;
 
-    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);
+  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;
+  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;
+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);
+  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;
+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;
 
-    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);
+  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;
+  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;
+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);
+  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;
+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;
 
-    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);
+  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;
+  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;
+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);
+  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;
+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);
-    }
+  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;
+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;
 
-    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;
+  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);
+  } 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);
-        }
+    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;
+  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;
+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(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);
-    }
+  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;
+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;
 
-    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);
+  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;
+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;
 
-    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);
+  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");
+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);
+  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
 
 /* Slightly bizarrely, the library seems to silently ignore entity
  * definitions for predefined entities, even when they are wrong.  The
  * 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?,"
         "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
         "))))))))))))))))))))))))))))))))>\n"
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
+  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");
+  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";
+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");
+  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;
+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;
 
-    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;
+  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";
+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);
+  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 };
+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");
+  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);
+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);
 
-    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);
+  UNUSED_P(base);
+  UNUSED_P(publicId);
+  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);
+  return XML_STATUS_OK;
 }
 
-START_TEST(test_undefined_ext_entity_in_external_dtd)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo'>\n"
-        "<doc></doc>\n";
+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);
+  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(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);
+  /* 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;
+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);
-    }
+  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"
         "<c1/><c2/><c3/><c4/><c5/><c6/><c7/><c8/>\n"
         "<d1/><d2/><d3/><d4/><d5/><d6/><d7/>\n"
         "<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_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"
+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;
+  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);
+  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);
+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;
+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);
+  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;
+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;
 
-    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);
-    }
+  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;
+  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
-    };
+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);
+  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
-    };
+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);
+  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
-    };
+  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");
+  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;
+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);
+  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;
+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);
+  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;
+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);
+  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;
+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);
+  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";
+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 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
 
-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>";
+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
 
 /* Test that the unknown encoding handler with map entries that expect
  * 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 */
+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;
+  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;
+  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;
+  /* 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;
+  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;
+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;
 
-    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");
+  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);
     }
-    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);
-    }
+  } 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;
+  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);
+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
-    };
+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 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
 
-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
-    };
+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 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
 
-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
-    };
+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
 
 /* Test little-endian UTF-16 given no explicit encoding.
  * The existing default encoding (UTF-8) is assumed to hold without a
  * BOM to contradict it, so the entity value will in fact provoke an
  * error because 0x00 is not a valid XML character.  We parse the
  * whole buffer in one go rather than feeding it in byte by byte to
  * 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;
+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;
 
-    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);
+  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;
+  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
-    };
+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");
+  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);
+  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
 
-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;
+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(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_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;
+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;
 
-    CharData_AppendXMLChars(storage, entityName, -1);
-    CharData_AppendXMLChars(storage, XCS("="), 1);
-    CharData_AppendXMLChars(storage, value, value_length);
-    CharData_AppendXMLChars(storage, XCS("\n"), 1);
+  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>";
+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
 
 /* Test that an invalid attribute description keyword consisting of
  * 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 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_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;
+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);
+  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;
+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_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
 
 /*
  * Namespaces tests.
  */
 
 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.
    The expected values are passed as an array reference of string pointers
    provided as the userData argument; the first is the expected
    element name, and the second is the expected attribute name.
 */
 static int triplet_start_flag = XML_FALSE;
 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
    the expected value.  The expected value is passed as the first element
    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;
+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");
+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;
+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;
 
-    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/>");
+  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;
+  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");
+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_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
 
 /* Test that the parsing status is correctly reset by XML_ParserReset().
  * 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;
+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");
+  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
 
 /* Test having a long namespaced element name inside a short one.
  * 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/' />";
+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");
+  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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":a='12'";
-    const char *text2 =
-        " xmlns:"
+  const char *text2
+      = " xmlns:"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "='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;
+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);
+  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>";
+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 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);
+  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>";
+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)
 
 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;
+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");
+  /* 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
 
 /* Test the version information is consistent */
 
 /* Since we are working in XML_LChars (potentially 16-bits), we
  * can't use the standard C library functions for character
  * manipulation and have to roll our own.
  */
 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;
+              XML_Expat_Version *version_struct) {
+  if (! version_text)
+    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;
+  while (*version_text != 0x00) {
+    if (*version_text >= ASCII_0 && *version_text <= ASCII_9)
+      break;
+    version_text++;
+  }
+  if (*version_text == 0x00)
+    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;
+  /* 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;
 
-    /* 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;
+  /* 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);
+               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();
+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");
+  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();
+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");
+  /* 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
-    };
+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;
+  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;
+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");
+  g_parser = XML_ParserCreate(XCS("UTF-16LE"));
+  if (g_parser == NULL)
+    fail("Parser not created");
 
-    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);
+  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;
 
 static void
-alloc_setup(void)
-{
-    XML_Memory_Handling_Suite memsuite = {
-        duff_allocator,
-        duff_reallocator,
-        free
-    };
+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++;
+}
 
-    /* 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");
+static void
+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;
+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");
+  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
 
 /* As above, but with an encoding big enough to cause storing the
  * 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;
+long_encoding_handler(void *userData, const XML_Char *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;
+  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='"
+START_TEST(test_alloc_parse_xdecl_2) {
+  const char *text
+      = "<?xml version='1.0' encoding='"
         /* Each line is 64 characters */
         "ThisIsAStupidlyLongEncodingNameIntendedToTriggerPoolGrowth123456"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN"
         "'?>"
         "<doc>Hello, world</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;
-        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");
+  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;
+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");
+  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;
+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");
+  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 =
-        "<?"
+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      "
         "allocator fails at a cruicial moment FGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "Q?><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;
-        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");
+  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;
+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");
+  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;
+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");
+  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;
+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;
 
-    /* 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;
-        }
+  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");
+  }
+  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 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;
+  /* 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)*>";
+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");
-    }
+  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;
+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");
+  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;
+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;
 
-    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;
-        }
+  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;
     }
-
-    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;
+    /* 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;
     }
-    XML_ParserFree(new_parser);
-    return XML_STATUS_OK;
+    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;
+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;
 
-    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;
+  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;
+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();
-    }
+  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;
+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;
 
-    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);
+  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;
+    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;
+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");
+  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;
+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;
+    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;
+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");
+  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;
+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");
+  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;
+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");
+  /* 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;
+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;
 
-    ext_parser = XML_ExternalEntityParserCreate(parser, context, NULL);
-    if (ext_parser == NULL)
-        fail("Could not create external entity 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");
 
-    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;
+  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;
+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");
+  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;
+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");
+  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 */
         "ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "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");
+  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"
+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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         " PUBLIC 'foo' 'bar.ent'>\n"
         "%ThisIsAStupidlyLongParameterNameIntendedToTriggerPoolGrowth12345"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP;";
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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"
+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/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "' 'test'>\n"
         "<doc></doc>";
-    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;
-        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");
+  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"
+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"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "'>\n"
         "<doc></doc>";
-    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;
-        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");
+  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;
+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;
 
-    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;
+  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;
+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");
+  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;
+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");
+  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 */
         "|ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO)"
         " 'default'>";
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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 */
         "(ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
         " #IMPLIED>\n"
         "]><doc/>";
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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 */
         "(ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|BBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|CBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|DBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|EBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|FBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|GBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|HBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|IBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|JBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|KBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|LBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|MBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|NBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|OBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO"
         "|PBCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMN)"
         " 'ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNO'"
         ">\n]><doc/>";
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         " SYSTEM 'http://example.org/n'>\n"
         "<!ENTITY e SYSTEM 'http://example.org/e' NDATA "
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ">\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/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "' 'foo'>\n"
         "<!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/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "'>\n"
         "<!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
 
-START_TEST(test_alloc_nested_groups)
-{
-    const char *text =
-        "<!DOCTYPE doc [\n"
+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?,"
         "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
         "))))))))))))))))))))))))))))))))>\n"
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
-    int i;
-    const int max_alloc_count = 20;
+  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();
-    }
+  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");
+  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"
+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?,"
         "(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?,(e?"
         "))))))))))))))))))))))))))))))))>\n"
         "<!ELEMENT e EMPTY>"
         "]>\n"
         "<doc><e/></doc>";
-    CharData storage;
-    int i;
-    const int max_realloc_count = 10;
+  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();
-    }
+  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");
+  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;
+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");
+  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;
+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");
+  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;
+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(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");
+  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;
+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");
+  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 '"
+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   "
         "that the library adds internally will trigger the string pool to"
         "grow. GHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "'>]>\n"
         "<doc a='&foo;'></doc>";
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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;
+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");
+  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;
+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");
+  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 character reference at the end of a suitably long
  * 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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "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
 
 /* Test that an error in a nested parameter entity substitution is
  * handled correctly.  It seems unlikely that the code path being
  * 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
-    };
+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");
+  /* 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 \""
+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 "
         "string pool to have to grow.  This allows us to test the alloc  "
         "failure path from that point. OPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDE"
         "\">\n'>"
         "%pe;\n";
-    int i;
-    const int max_realloc_count = 5;
+  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");
+  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 \""
+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     "
         "grow.  This allows us to test the allocation failure path from  "
         "that point onwards. EFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFG&#x51;"
         "\">\n'>"
         "%pe;\n";
-    int i;
-    const int max_realloc_count = 5;
+  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");
+  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;
+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();
-    }
+  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");
+  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;
+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");
+  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 */
+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/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/");
-    int i;
-    const int max_alloc_count = 25;
+  /* clang-format on */
+  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();
+  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 (i == 0)
-        fail("Parsing worked despite failing allocations");
-    else if (i == max_alloc_count)
-        fail("Parsing failed even at max allocation count");
+    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"
+START_TEST(test_alloc_long_public_id) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ENTITY e PUBLIC '"
         /* 64 characters per line */
         "LongPublicIDThatShouldResultInAnInternalStringPoolGrowingAtASpec"
         "ificMomentKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "' 'bar'>\n"
         "]>\n"
         "<doc>&e;</doc>";
-    char entity_text[] = "Hello world";
-    int i;
-    const int max_alloc_count = 40;
+  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");
+  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"
+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"
         "e setting up to parse the external entity below. xyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "'>\n"
         "  <!ENTITY e2 SYSTEM 'bar'>\n"
         "]>\n"
         "<doc>&e2;</doc>";
-    char entity_text[] = "Hello world";
-    int i;
-    const int max_alloc_count = 40;
+  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");
+  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"
+START_TEST(test_alloc_long_notation) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!NOTATION note SYSTEM '"
         /* 64 characters per line */
         "ALongNotationNameThatShouldProvokeStringPoolGrowthWhileCallingAn"
         "ExternalEntityParserUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "'>\n"
         "  <!ENTITY e1 SYSTEM 'foo' NDATA "
         /* 64 characters per line */
         "ALongNotationNameThatShouldProvokeStringPoolGrowthWhileCallingAn"
         "ExternalEntityParserUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AB"
         ">\n"
         "  <!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;
+  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;
+  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");
+    /* 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' };
+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");
+  /* 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;
+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");
+  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;
+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");
+  /* 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(parser, 0, XML_FALSE) != XML_STATUS_OK)
-        xml_failure(parser);
+  /* 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(parser) != XML_STATUS_ERROR)
-        fail("Resuming unsuspended parser not faulted");
-    if (XML_GetErrorCode(parser) != XML_ERROR_NOT_SUSPENDED)
-        xml_failure(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(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 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(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");
+  /* 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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":foo xmlns:"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='http://example.org/'>"
         "</"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "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/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "' bar:a='12'\n"
         "xmlns:bar='http://example.org/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789A/"
         "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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":a='12'\n"
         "xmlns:"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "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")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
         XCS("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ")
-    };
-    int i;
-    const int max_alloc_count = 40;
+      /* clang-format on */
+  };
+  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");
+  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;
+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");
+  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;
+  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");
+  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
 
 /* Test the effects of reallocation failure when reassigning a
  * binding.
  *
  * XML_ParserReset does not free the BINDING structures used by a
  * parser, but instead adds them to an internal free list to be reused
  * as necessary.  Likewise the URI buffers allocated for the binding
  * aren't freed, but kept attached to their existing binding.  If the
  * 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"
+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>";
-    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;
+  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);
+  /* 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(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");
+  /* 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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":foo xmlns:"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='http://example.org/'>"
         "</"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":foo>";
-    int i;
-    const int max_realloc_count = 12;
+  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");
+  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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "Q:foo xmlns:"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "Q='http://example.org/'>"
         "</"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "Q:foo>";
-    int i;
-    const int max_realloc_count = 12;
+  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");
+  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 =
-        "<"
+START_TEST(test_nsalloc_long_namespace) {
+  const char *text1
+      = "<"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":e xmlns:"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "='http://example.org/'>\n";
-    const char *text2 =
-        "<"
+  const char *text2
+      = "<"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":f "
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":attr='foo'/>\n"
         "</"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         ":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, 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");
+  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"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         ":e xmlns:"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         "='http://example.org/'>\n"
         "<"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         ":f "
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         ":att='foo'/>\n"
         "</"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789AZ"
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678"
         ":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
 
-START_TEST(test_nsalloc_long_context)
-{
-    const char *text =
-        "<!DOCTYPE doc SYSTEM 'foo' [\n"
+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"
         "<doc xmlns='http://example.org/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKL"
         "' 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;
+  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;
+  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");
+    /* 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
 
 /* This function is void; it will throw a fail() on error, so if it
  * 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;
+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");
+  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"
+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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKL"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJK"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGH"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABC"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNOP"
         "'>\n"
         "&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/"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLM"
         "'>\n"
         "&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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         " SYSTEM 'bar'>\n"
         "]>\n"
         "<doc xmlns='http://example.org/baz'>\n"
         "&"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ";"
         "</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<!ELEMENT el EMPTY>" },
-        { XCS("bar"), "<el/>" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_realloc_count = 10;
+  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");
+  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
 
 /* Test that when a namespace is passed through the context mechanism
  * to an external entity parser, the parsers handle reallocation
  * 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"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":doc [\n"
         "  <!ENTITY First SYSTEM 'foo/First'>\n"
         "]>\n"
         "<"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":doc xmlns:"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "='foo/Second'>&First;";
-    const char *text2 = "</"
+  const char *text2
+      = "</"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         ":doc>";
-    ExtOption options[] = {
-        { XCS("foo/First"), "Hello world" },
-        { NULL, NULL }
-    };
-    int i;
-    const int max_realloc_count = 20;
+  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");
+  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"
+START_TEST(test_nsalloc_long_default_in_ext) {
+  const char *text
+      = "<!DOCTYPE doc [\n"
         "  <!ATTLIST e a1 CDATA '"
         /* 64 characters per line */
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "ABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOPABCDEFGHIJKLMNOP"
         "'>\n"
         "  <!ENTITY x SYSTEM 'foo'>\n"
         "]>\n"
         "<doc>&x;</doc>";
-    ExtOption options[] = {
-        { XCS("foo"), "<e/>"},
-        { NULL, NULL }
-    };
-    int i;
-    const int max_alloc_count = 50;
+  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;
+  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");
+    /* 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"
+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/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/"
         "'>\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/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             XCS("ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/ABCDEFGHIJKLMNO/")
             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;
+       /* 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(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;
+  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");
+    /* 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;
+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;
+  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");
+    /* 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");
+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_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_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_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_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);
+  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;
+  return s;
 }
 
-
 int
-main(int argc, char *argv[])
-{
-    int i, nf;
-    int verbosity = CK_NORMAL;
-    Suite *s = make_suite();
-    SRunner *sr = srunner_create(s);
+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();
+  /* 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;
-        }
+  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;
 }
Index: vendor/expat/dist/tests/structdata.c
===================================================================
--- vendor/expat/dist/tests/structdata.c	(revision 355070)
+++ vendor/expat/dist/tests/structdata.c	(revision 355071)
@@ -1,162 +1,155 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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 "structdata.h"
 #include "minicheck.h"
 
 #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);
+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;
+  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;
+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;
+  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;
-    }
+    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++;
+  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;
+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);
-    }
-    for (i = 0; i < count; i++)
-    {
-        const StructDataEntry *got = &storage->entries[i];
-        const StructDataEntry *want = &expected[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];
 
-        if (xcstrcmp(got->str, want->str) != 0) {
-            StructData_Dispose(storage);
-            fail("structure got bad string");
+      assert(got != NULL);
+      assert(want != NULL);
+
+      if (xcstrcmp(got->str, want->str) != 0) {
+        StructData_Dispose(storage);
+        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);
         }
-        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;
+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);
+  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;
 }
Index: vendor/expat/dist/tests/structdata.h
===================================================================
--- vendor/expat/dist/tests/structdata.h	(revision 355070)
+++ vendor/expat/dist/tests/structdata.h	(revision 355071)
@@ -1,76 +1,70 @@
 /* Interface to some helper routines used to accumulate and check
    structured content.
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #ifdef __cplusplus
 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
 }
 #endif
Index: vendor/expat/dist/tests/xmltest.sh
===================================================================
--- vendor/expat/dist/tests/xmltest.sh	(revision 355070)
+++ vendor/expat/dist/tests/xmltest.sh	(revision 355071)
@@ -1,147 +1,142 @@
 #! /usr/bin/env bash
 
 #   EXPAT TEST SCRIPT FOR W3C XML TEST SUITE
 
 # This script can be used to exercise Expat against the
 # w3c.org xml test suite, available from
 # http://www.w3.org/XML/Test/xmlts20020606.zip.
 
 # To run this script, first set XMLWF below so that xmlwf can be
 # found, then set the output directory with OUTPUT.
 
 # The script lists all test cases where Expat shows a discrepancy
 # from the expected result. Test cases where only the canonical
 # output differs are prefixed with "Output differs:", and a diff file
 # is generated in the appropriate subdirectory under $OUTPUT.
 
 # If there are output files provided, the script will use
 # output from xmlwf and compare the desired output against it.
 # However, one has to take into account that the canonical output
 # produced by xmlwf conforms to an older definition of canonical XML
 # and does not generate notation declarations.
 
 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
 # reldir includes trailing slash
 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
       return 0
   fi 
 }
 
 # RunXmlwfWF file reldir
 # reldir includes trailing slash
 RunXmlwfWF() {
   file="$1"
   reldir="$2"
   $XMLWF -p -N -d "$OUTPUT$reldir" "$file" > outfile || return $?
   read outdata < outfile 
   if test "$outdata" = "" ; then 
       if [ -f "out/$file" ] ; then 
           $DIFF "$OUTPUT$reldir$file" "out/$file" > outfile 
           if [ -s outfile ] ; then 
               cp outfile "$OUTPUT$reldir$file.diff"
               echo "Output differs: $reldir$file"
               return 1
           fi 
       fi 
       return 0
   else 
       echo "In $reldir: $outdata"
       return 1
   fi 
 }
 
 SUCCESS=0
 ERROR=0
 
 UpdateStatus() {
   if [ "$1" -eq 0 ] ; then
     SUCCESS=`expr $SUCCESS + 1`
   else
     ERROR=`expr $ERROR + 1`
   fi
 }
 
 ##########################
 # well-formed test cases #
 ##########################
 
 cd "$TS/xmlconf"
 for xmldir in ibm/valid/P* \
               ibm/invalid/P* \
               xmltest/valid/ext-sa \
               xmltest/valid/not-sa \
               xmltest/invalid \
               xmltest/invalid/not-sa \
               xmltest/valid/sa \
               sun/valid \
               sun/invalid ; do
   cd "$TS/xmlconf/$xmldir"
   mkdir -p "$OUTPUT$xmldir"
   for xmlfile in $(ls -1 *.xml | sort -d) ; do
       [[ -f "$xmlfile" ]] || continue
       RunXmlwfWF "$xmlfile" "$xmldir/"
       UpdateStatus $?
   done
   rm -f outfile
 done
 
 cd "$TS/xmlconf/oasis"
 mkdir -p "$OUTPUT"oasis
 for xmlfile in *pass*.xml ; do
     RunXmlwfWF "$xmlfile" "oasis/"
     UpdateStatus $?
 done
 rm outfile
 
 ##############################
 # not well-formed test cases #
 ##############################
 
 cd "$TS/xmlconf"
 for xmldir in ibm/not-wf/P* \
               ibm/not-wf/p28a \
               ibm/not-wf/misc \
               xmltest/not-wf/ext-sa \
               xmltest/not-wf/not-sa \
               xmltest/not-wf/sa \
               sun/not-wf ; do
   cd "$TS/xmlconf/$xmldir"
   for xmlfile in *.xml ; do
       RunXmlwfNotWF "$xmlfile" "$xmldir/"
       UpdateStatus $?
   done
-  rm outfile
 done
 
 cd "$TS/xmlconf/oasis"
 for xmlfile in *fail*.xml ; do
     RunXmlwfNotWF "$xmlfile" "oasis/"
     UpdateStatus $?
 done
-rm outfile
 
 echo "Passed: $SUCCESS"
 echo "Failed: $ERROR"
Index: vendor/expat/dist/xmlwf/Makefile.am
===================================================================
--- vendor/expat/dist/xmlwf/Makefile.am	(revision 355070)
+++ vendor/expat/dist/xmlwf/Makefile.am	(revision 355071)
@@ -1,61 +1,59 @@
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 bin_PROGRAMS = xmlwf
 
 xmlwf_LDADD = ../lib/libexpat.la
 xmlwf_SOURCES = \
     xmlwf.c \
     xmlfile.c \
     codepage.c \
     @FILEMAP@.c
 
 xmlwf_CPPFLAGS = -I$(srcdir)/../lib
 
 if MINGW
 if UNICODE
 xmlwf_CPPFLAGS += -mwindows
 xmlwf_LDFLAGS = -municode
 endif
 endif
 
 EXTRA_DIST = \
     codepage.h \
     ct.c \
     filemap.h \
     readfilemap.c \
     unixfilemap.c \
     win32filemap.c \
     xmlfile.h \
     xmlmime.c \
     xmlmime.h \
-    xmltchar.h \
-    xmlurl.h \
-    xmlwin32url.cxx
+    xmltchar.h
Index: vendor/expat/dist/xmlwf/Makefile.in
===================================================================
--- vendor/expat/dist/xmlwf/Makefile.in	(revision 355070)
+++ vendor/expat/dist/xmlwf/Makefile.in	(revision 355071)
@@ -1,753 +1,776 @@
-# 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,
 # with or without modifications, as long as this notice is preserved.
 
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 # even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.
 
 @SET_MAKE@
 
 #
 #                          __  __            _
 #                       ___\ \/ /_ __   __ _| |_
 #                      / _ \\  /| '_ \ / _` | __|
 #                     |  __//  \| |_) | (_| | |_
 #                      \___/_/\_\ .__/ \__,_|\__|
 #                               |_| XML parser
 #
 # Copyright (c) 2017 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.
 
 VPATH = @srcdir@
 am__is_gnu_make = { \
   if test -z '$(MAKELEVEL)'; then \
     false; \
   elif test -n '$(MAKE_HOST)'; then \
     true; \
   elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
     true; \
   else \
     false; \
   fi; \
 }
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
       *) echo "am__make_running_with_option: internal error: invalid" \
               "target option '$${target_option-}' specified" >&2; \
          exit 1;; \
   esac; \
   has_opt=no; \
   sane_makeflags=$$MAKEFLAGS; \
   if $(am__is_gnu_make); then \
     sane_makeflags=$$MFLAGS; \
   else \
     case $$MAKEFLAGS in \
       *\\[\ \	]*) \
         bs=\\; \
         sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \
           | sed "s/$$bs$$bs[$$bs $$bs	]*//g"`;; \
     esac; \
   fi; \
   skip_next=no; \
   strip_trailopt () \
   { \
     flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \
   }; \
   for flg in $$sane_makeflags; do \
     test $$skip_next = yes && { skip_next=no; continue; }; \
     case $$flg in \
       *=*|--*) continue;; \
         -*I) strip_trailopt 'I'; skip_next=yes;; \
       -*I?*) strip_trailopt 'I';; \
         -*O) strip_trailopt 'O'; skip_next=yes;; \
       -*O?*) strip_trailopt 'O';; \
         -*l) strip_trailopt 'l'; skip_next=yes;; \
       -*l?*) strip_trailopt 'l';; \
       -[dEDm]) skip_next=yes;; \
       -[JT]) skip_next=yes;; \
     esac; \
     case $$flg in \
       *$$target_option*) has_opt=yes; break;; \
     esac; \
   done; \
   test $$has_opt = yes
 am__make_dryrun = (target_option=n; $(am__make_running_with_option))
 am__make_keepgoing = (target_option=k; $(am__make_running_with_option))
 pkgdatadir = $(datadir)/@PACKAGE@
 pkgincludedir = $(includedir)/@PACKAGE@
 pkglibdir = $(libdir)/@PACKAGE@
 pkglibexecdir = $(libexecdir)/@PACKAGE@
 am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
 install_sh_DATA = $(install_sh) -c -m 644
 install_sh_PROGRAM = $(install_sh) -c
 install_sh_SCRIPT = $(install_sh) -c
 INSTALL_HEADER = $(INSTALL_DATA)
 transform = $(program_transform_name)
 NORMAL_INSTALL = :
 PRE_INSTALL = :
 POST_INSTALL = :
 NORMAL_UNINSTALL = :
 PRE_UNINSTALL = :
 POST_UNINSTALL = :
 build_triplet = @build@
 host_triplet = @host@
 bin_PROGRAMS = xmlwf$(EXEEXT)
 @MINGW_TRUE@@UNICODE_TRUE@am__append_1 = -mwindows
 subdir = xmlwf
 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)
 DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON)
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = $(top_builddir)/expat_config.h
 CONFIG_CLEAN_FILES =
 CONFIG_CLEAN_VPATH_FILES =
 am__installdirs = "$(DESTDIR)$(bindir)"
 PROGRAMS = $(bin_PROGRAMS)
 am_xmlwf_OBJECTS = xmlwf-xmlwf.$(OBJEXT) xmlwf-xmlfile.$(OBJEXT) \
 	xmlwf-codepage.$(OBJEXT) xmlwf-@FILEMAP@.$(OBJEXT)
 xmlwf_OBJECTS = $(am_xmlwf_OBJECTS)
 xmlwf_DEPENDENCIES = ../lib/libexpat.la
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
 am__v_lt_0 = --silent
 am__v_lt_1 = 
 xmlwf_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(xmlwf_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
 am__v_P_1 = :
 AM_V_GEN = $(am__v_GEN_@AM_V@)
 am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@)
 am__v_GEN_0 = @echo "  GEN     " $@;
 am__v_GEN_1 = 
 AM_V_at = $(am__v_at_@AM_V@)
 am__v_at_ = $(am__v_at_@AM_DEFAULT_V@)
 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)
 LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
 	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
 	$(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
 am__v_CC_0 = @echo "  CC      " $@;
 am__v_CC_1 = 
 CCLD = $(CC)
 LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
 SOURCES = $(xmlwf_SOURCES)
 DIST_SOURCES = $(xmlwf_SOURCES)
 am__can_run_installinfo = \
   case $$AM_UPDATE_INFO_DIR in \
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
 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
 # *not* preserved.
 am__uniquify_input = $(AWK) '\
   BEGIN { nonempty = 0; } \
   { items[$$0] = 1; nonempty = 1; } \
   END { if (nonempty) { for (i in items) print i; }; } \
 '
 # Make sure the list of sources is unique.  This is necessary because,
 # e.g., the same source file might be shared among _SOURCES variables
 # for different programs/libraries.
 am__define_uniq_tagged_files = \
   list='$(am__tagged_files)'; \
   unique=`for i in $$list; do \
     if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
   done | $(am__uniquify_input)`
 ETAGS = etags
 CTAGS = ctags
 am__DIST_COMMON = $(srcdir)/Makefile.in \
 	$(top_srcdir)/conftools/depcomp
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 ACLOCAL = @ACLOCAL@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
 AR = @AR@
 AS = @AS@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
 CFLAGS = @CFLAGS@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
 DLLTOOL = @DLLTOOL@
 DOCBOOK_TO_MAN = @DOCBOOK_TO_MAN@
 DSYMUTIL = @DSYMUTIL@
 DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
 ECHO_T = @ECHO_T@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
 FGREP = @FGREP@
 FILEMAP = @FILEMAP@
 GREP = @GREP@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
 LIBAGE = @LIBAGE@
 LIBCURRENT = @LIBCURRENT@
 LIBOBJS = @LIBOBJS@
 LIBREVISION = @LIBREVISION@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
 LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
 NM = @NM@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
 PACKAGE_NAME = @PACKAGE_NAME@
 PACKAGE_STRING = @PACKAGE_STRING@
 PACKAGE_TARNAME = @PACKAGE_TARNAME@
 PACKAGE_URL = @PACKAGE_URL@
 PACKAGE_VERSION = @PACKAGE_VERSION@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
 STRIP = @STRIP@
 VERSION = @VERSION@
 abs_builddir = @abs_builddir@
 abs_srcdir = @abs_srcdir@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
 am__quote = @am__quote@
 am__tar = @am__tar@
 am__untar = @am__untar@
 bindir = @bindir@
 build = @build@
 build_alias = @build_alias@
 build_cpu = @build_cpu@
 build_os = @build_os@
 build_vendor = @build_vendor@
 builddir = @builddir@
 datadir = @datadir@
 datarootdir = @datarootdir@
 docdir = @docdir@
 dvidir = @dvidir@
 exec_prefix = @exec_prefix@
 host = @host@
 host_alias = @host_alias@
 host_cpu = @host_cpu@
 host_os = @host_os@
 host_vendor = @host_vendor@
 htmldir = @htmldir@
 includedir = @includedir@
 infodir = @infodir@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
 mkdir_p = @mkdir_p@
 oldincludedir = @oldincludedir@
 pdfdir = @pdfdir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 xmlwf_LDADD = ../lib/libexpat.la
 xmlwf_SOURCES = \
     xmlwf.c \
     xmlfile.c \
     codepage.c \
     @FILEMAP@.c
 
 xmlwf_CPPFLAGS = -I$(srcdir)/../lib $(am__append_1)
 @MINGW_TRUE@@UNICODE_TRUE@xmlwf_LDFLAGS = -municode
 EXTRA_DIST = \
     codepage.h \
     ct.c \
     filemap.h \
     readfilemap.c \
     unixfilemap.c \
     win32filemap.c \
     xmlfile.h \
     xmlmime.c \
     xmlmime.h \
-    xmltchar.h \
-    xmlurl.h \
-    xmlwin32url.cxx
+    xmltchar.h
 
 all: all-am
 
 .SUFFIXES:
 .SUFFIXES: .c .lo .o .obj
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
 	@for dep in $?; do \
 	  case '$(am__configure_deps)' in \
 	    *$$dep*) \
 	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
 	        && { if test -f $@; then exit 0; else break; fi; }; \
 	      exit 1;; \
 	  esac; \
 	done; \
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu xmlwf/Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --gnu xmlwf/Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *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)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 
 $(top_srcdir)/configure:  $(am__configure_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(ACLOCAL_M4):  $(am__aclocal_m4_deps)
 	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
 $(am__aclocal_m4_deps):
 install-binPROGRAMS: $(bin_PROGRAMS)
 	@$(NORMAL_INSTALL)
 	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
 	if test -n "$$list"; then \
 	  echo " $(MKDIR_P) '$(DESTDIR)$(bindir)'"; \
 	  $(MKDIR_P) "$(DESTDIR)$(bindir)" || exit 1; \
 	fi; \
 	for p in $$list; do echo "$$p $$p"; done | \
 	sed 's/$(EXEEXT)$$//' | \
 	while read p p1; do if test -f $$p \
 	 || test -f $$p1 \
 	  ; then echo "$$p"; echo "$$p"; else :; fi; \
 	done | \
 	sed -e 'p;s,.*/,,;n;h' \
 	    -e 's|.*|.|' \
 	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
 	sed 'N;N;N;s,\n, ,g' | \
 	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
 	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
 	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
 	    else { print "f", $$3 "/" $$4, $$1; } } \
 	  END { for (d in files) print "f", d, files[d] }' | \
 	while read type dir files; do \
 	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
 	    test -z "$$files" || { \
 	    echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
 	    $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
 	    } \
 	; done
 
 uninstall-binPROGRAMS:
 	@$(NORMAL_UNINSTALL)
 	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
 	files=`for p in $$list; do echo "$$p"; done | \
 	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
 	      -e 's/$$/$(EXEEXT)/' \
 	`; \
 	test -n "$$list" || exit 0; \
 	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
 	cd "$(DESTDIR)$(bindir)" && rm -f $$files
 
 clean-binPROGRAMS:
 	@list='$(bin_PROGRAMS)'; test -n "$$list" || exit 0; \
 	echo " rm -f" $$list; \
 	rm -f $$list || exit $$?; \
 	test -n "$(EXEEXT)" || exit 0; \
 	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
 	echo " rm -f" $$list; \
 	rm -f $$list
 
 xmlwf$(EXEEXT): $(xmlwf_OBJECTS) $(xmlwf_DEPENDENCIES) $(EXTRA_xmlwf_DEPENDENCIES) 
 	@rm -f xmlwf$(EXEEXT)
 	$(AM_V_CCLD)$(xmlwf_LINK) $(xmlwf_OBJECTS) $(xmlwf_LDADD) $(LIBS)
 
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 
 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 $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $<
 
 .c.obj:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
 .c.lo:
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
 xmlwf-xmlwf.o: xmlwf.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-xmlwf.o -MD -MP -MF $(DEPDIR)/xmlwf-xmlwf.Tpo -c -o xmlwf-xmlwf.o `test -f 'xmlwf.c' || echo '$(srcdir)/'`xmlwf.c
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-xmlwf.Tpo $(DEPDIR)/xmlwf-xmlwf.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='xmlwf.c' object='xmlwf-xmlwf.o' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-xmlwf.o `test -f 'xmlwf.c' || echo '$(srcdir)/'`xmlwf.c
 
 xmlwf-xmlwf.obj: xmlwf.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-xmlwf.obj -MD -MP -MF $(DEPDIR)/xmlwf-xmlwf.Tpo -c -o xmlwf-xmlwf.obj `if test -f 'xmlwf.c'; then $(CYGPATH_W) 'xmlwf.c'; else $(CYGPATH_W) '$(srcdir)/xmlwf.c'; fi`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-xmlwf.Tpo $(DEPDIR)/xmlwf-xmlwf.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='xmlwf.c' object='xmlwf-xmlwf.obj' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-xmlwf.obj `if test -f 'xmlwf.c'; then $(CYGPATH_W) 'xmlwf.c'; else $(CYGPATH_W) '$(srcdir)/xmlwf.c'; fi`
 
 xmlwf-xmlfile.o: xmlfile.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-xmlfile.o -MD -MP -MF $(DEPDIR)/xmlwf-xmlfile.Tpo -c -o xmlwf-xmlfile.o `test -f 'xmlfile.c' || echo '$(srcdir)/'`xmlfile.c
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-xmlfile.Tpo $(DEPDIR)/xmlwf-xmlfile.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='xmlfile.c' object='xmlwf-xmlfile.o' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-xmlfile.o `test -f 'xmlfile.c' || echo '$(srcdir)/'`xmlfile.c
 
 xmlwf-xmlfile.obj: xmlfile.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-xmlfile.obj -MD -MP -MF $(DEPDIR)/xmlwf-xmlfile.Tpo -c -o xmlwf-xmlfile.obj `if test -f 'xmlfile.c'; then $(CYGPATH_W) 'xmlfile.c'; else $(CYGPATH_W) '$(srcdir)/xmlfile.c'; fi`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-xmlfile.Tpo $(DEPDIR)/xmlwf-xmlfile.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='xmlfile.c' object='xmlwf-xmlfile.obj' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-xmlfile.obj `if test -f 'xmlfile.c'; then $(CYGPATH_W) 'xmlfile.c'; else $(CYGPATH_W) '$(srcdir)/xmlfile.c'; fi`
 
 xmlwf-codepage.o: codepage.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-codepage.o -MD -MP -MF $(DEPDIR)/xmlwf-codepage.Tpo -c -o xmlwf-codepage.o `test -f 'codepage.c' || echo '$(srcdir)/'`codepage.c
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-codepage.Tpo $(DEPDIR)/xmlwf-codepage.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='codepage.c' object='xmlwf-codepage.o' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-codepage.o `test -f 'codepage.c' || echo '$(srcdir)/'`codepage.c
 
 xmlwf-codepage.obj: codepage.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-codepage.obj -MD -MP -MF $(DEPDIR)/xmlwf-codepage.Tpo -c -o xmlwf-codepage.obj `if test -f 'codepage.c'; then $(CYGPATH_W) 'codepage.c'; else $(CYGPATH_W) '$(srcdir)/codepage.c'; fi`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-codepage.Tpo $(DEPDIR)/xmlwf-codepage.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='codepage.c' object='xmlwf-codepage.obj' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-codepage.obj `if test -f 'codepage.c'; then $(CYGPATH_W) 'codepage.c'; else $(CYGPATH_W) '$(srcdir)/codepage.c'; fi`
 
 xmlwf-@FILEMAP@.o: @FILEMAP@.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-@FILEMAP@.o -MD -MP -MF $(DEPDIR)/xmlwf-@FILEMAP@.Tpo -c -o xmlwf-@FILEMAP@.o `test -f '@FILEMAP@.c' || echo '$(srcdir)/'`@FILEMAP@.c
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-@FILEMAP@.Tpo $(DEPDIR)/xmlwf-@FILEMAP@.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='@FILEMAP@.c' object='xmlwf-@FILEMAP@.o' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-@FILEMAP@.o `test -f '@FILEMAP@.c' || echo '$(srcdir)/'`@FILEMAP@.c
 
 xmlwf-@FILEMAP@.obj: @FILEMAP@.c
 @am__fastdepCC_TRUE@	$(AM_V_CC)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT xmlwf-@FILEMAP@.obj -MD -MP -MF $(DEPDIR)/xmlwf-@FILEMAP@.Tpo -c -o xmlwf-@FILEMAP@.obj `if test -f '@FILEMAP@.c'; then $(CYGPATH_W) '@FILEMAP@.c'; else $(CYGPATH_W) '$(srcdir)/@FILEMAP@.c'; fi`
 @am__fastdepCC_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/xmlwf-@FILEMAP@.Tpo $(DEPDIR)/xmlwf-@FILEMAP@.Po
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='@FILEMAP@.c' object='xmlwf-@FILEMAP@.obj' libtool=no @AMDEPBACKSLASH@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(xmlwf_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o xmlwf-@FILEMAP@.obj `if test -f '@FILEMAP@.c'; then $(CYGPATH_W) '@FILEMAP@.c'; else $(CYGPATH_W) '$(srcdir)/@FILEMAP@.c'; fi`
 
 mostlyclean-libtool:
 	-rm -f *.lo
 
 clean-libtool:
 	-rm -rf .libs _libs
 
 ID: $(am__tagged_files)
 	$(am__define_uniq_tagged_files); mkid -fID $$unique
 tags: tags-am
 TAGS: tags
 
 tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	set x; \
 	here=`pwd`; \
 	$(am__define_uniq_tagged_files); \
 	shift; \
 	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
 	  test -n "$$unique" || unique=$$empty_fix; \
 	  if test $$# -gt 0; then \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      "$$@" $$unique; \
 	  else \
 	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
 	      $$unique; \
 	  fi; \
 	fi
 ctags: ctags-am
 
 CTAGS: ctags
 ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files)
 	$(am__define_uniq_tagged_files); \
 	test -z "$(CTAGS_ARGS)$$unique" \
 	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
 	     $$unique
 
 GTAGS:
 	here=`$(am__cd) $(top_builddir) && pwd` \
 	  && $(am__cd) $(top_srcdir) \
 	  && gtags -i $(GTAGS_ARGS) "$$here"
 cscopelist: cscopelist-am
 
 cscopelist-am: $(am__tagged_files)
 	list='$(am__tagged_files)'; \
 	case "$(srcdir)" in \
 	  [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \
 	  *) sdir=$(subdir)/$(srcdir) ;; \
 	esac; \
 	for i in $$list; do \
 	  if test -f "$$i"; then \
 	    echo "$(subdir)/$$i"; \
 	  else \
 	    echo "$$sdir/$$i"; \
 	  fi; \
 	done >> $(top_builddir)/cscope.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)'; \
 	  dist_files=`for file in $$list; do echo $$file; done | \
 	  sed -e "s|^$$srcdirstrip/||;t" \
 	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
 	case $$dist_files in \
 	  */*) $(MKDIR_P) `echo "$$dist_files" | \
 			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
 			   sort -u` ;; \
 	esac; \
 	for file in $$dist_files; do \
 	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
 	  if test -d $$d/$$file; then \
 	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
 	    if test -d "$(distdir)/$$file"; then \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
 	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
 	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
 	    fi; \
 	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
 	  else \
 	    test -f "$(distdir)/$$file" \
 	    || cp -p $$d/$$file "$(distdir)/$$file" \
 	    || exit 1; \
 	  fi; \
 	done
 check-am: all-am
 check: check-am
 all-am: Makefile $(PROGRAMS)
 installdirs:
 	for dir in "$(DESTDIR)$(bindir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
 install: install-am
 install-exec: install-exec-am
 install-data: install-data-am
 uninstall: uninstall-am
 
 install-am: all-am
 	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
 
 installcheck: installcheck-am
 install-strip:
 	if test -z '$(STRIP)'; then \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	      install; \
 	else \
 	  $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
 	    install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
 	    "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
 	fi
 mostlyclean-generic:
 
 clean-generic:
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
 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
 
 dvi: dvi-am
 
 dvi-am:
 
 html: html-am
 
 html-am:
 
 info: info-am
 
 info-am:
 
 install-data-am:
 
 install-dvi: install-dvi-am
 
 install-dvi-am:
 
 install-exec-am: install-binPROGRAMS
 
 install-html: install-html-am
 
 install-html-am:
 
 install-info: install-info-am
 
 install-info-am:
 
 install-man:
 
 install-pdf: install-pdf-am
 
 install-pdf-am:
 
 install-ps: install-ps-am
 
 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
 
 mostlyclean: mostlyclean-am
 
 mostlyclean-am: mostlyclean-compile mostlyclean-generic \
 	mostlyclean-libtool
 
 pdf: pdf-am
 
 pdf-am:
 
 ps: ps-am
 
 ps-am:
 
 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 \
 	html-am info info-am install install-am install-binPROGRAMS \
 	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 maintainer-clean \
 	maintainer-clean-generic mostlyclean mostlyclean-compile \
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	tags tags-am uninstall uninstall-am uninstall-binPROGRAMS
 
 .PRECIOUS: Makefile
 
 
 # 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.
 .NOEXPORT:
Index: vendor/expat/dist/xmlwf/codepage.c
===================================================================
--- vendor/expat/dist/xmlwf/codepage.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/codepage.c	(revision 355071)
@@ -1,97 +1,99 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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;
       lim = info.LeadByte[i + 1];
       for (j = info.LeadByte[i]; j <= lim; j++)
         map[j] = -2;
     }
   }
   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;
 }
 
 #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;
 }
 
 #endif /* not _WIN32 */
Index: vendor/expat/dist/xmlwf/ct.c
===================================================================
--- vendor/expat/dist/xmlwf/ct.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/ct.c	(revision 355071)
@@ -1,179 +1,173 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #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;
   for (;;) {
     switch (**pp) {
     case '\0':
       return 0;
     case ' ':
     case '\r':
     case '\t':
     case '\n':
       if (state == inAtom)
         return tokStart;
       break;
     case '(':
       if (state == inAtom)
         return tokStart;
       if (state != inString)
         state++;
       break;
     case ')':
       if (state > init)
         --state;
       else if (state != inString)
         return 0;
       break;
     case ';':
     case '/':
     case '=':
       if (state == inAtom)
         return tokStart;
       if (state == init)
         return (*pp)++;
       break;
     case '\\':
       ++*pp;
       if (**pp == '\0')
         return 0;
       break;
     case '"':
       switch (state) {
       case inString:
         ++*pp;
         return tokStart;
       case inAtom:
         return tokStart;
       case init:
         tokStart = *pp;
         state = inString;
         break;
       }
       break;
     default:
       if (state == init) {
         tokStart = *pp;
         state = inAtom;
       }
       break;
     }
     ++*pp;
   }
   /* not reached */
 }
 
 /* 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'))
       return 0;
   return *key == '\0';
 }
 
 void
-getXMLCharset(const char *buf, char *charset)
-{
+getXMLCharset(const char *buf, char *charset) {
   const char *next, *p;
 
   charset[0] = '\0';
   next = buf;
   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"))
     isXml = 1;
   p = getTok(&next);
   while (p) {
     if (*p == ';') {
       p = getTok(&next);
       if (matchkey(p, next, "charset")) {
         p = getTok(&next);
         if (p && *p == '=') {
           p = getTok(&next);
           if (p) {
             char *s = charset;
             if (*p == '"') {
               while (++p != next - 1) {
                 if (*p == '\\')
                   ++p;
                 if (s == charset + CHARSET_MAX - 1) {
                   charset[0] = '\0';
                   break;
                 }
                 *s++ = *p;
               }
               *s++ = '\0';
-            }
-            else {
+            } else {
               if (next - p > CHARSET_MAX - 1)
                 break;
               while (p != next)
                 *s++ = *p++;
               *s = 0;
               break;
             }
           }
         }
       }
-    }
-  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);
   return 0;
 }
Index: vendor/expat/dist/xmlwf/filemap.h
===================================================================
--- vendor/expat/dist/xmlwf/filemap.h	(revision 355070)
+++ vendor/expat/dist/xmlwf/filemap.h	(revision 355071)
@@ -1,57 +1,53 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
-#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:
  *
  *    do {
  *      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
Index: vendor/expat/dist/xmlwf/readfilemap.c
===================================================================
--- vendor/expat/dist/xmlwf/readfilemap.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/readfilemap.c	(revision 355071)
@@ -1,141 +1,140 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #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"
 #include "filemap.h"
 
 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;
   }
   if (fstat(fd, &sb) < 0) {
     tperror(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;
   /* malloc will return NULL with nbytes == 0, handle files with size 0 */
   if (nbytes == 0) {
     static const char c = '\0';
     processor(&c, 0, name, arg);
     close(fd);
     return 1;
   }
   p = malloc(nbytes);
-  if (!p) {
+  if (! p) {
     ftprintf(stderr, T("%s: out of memory\n"), name);
     close(fd);
     return 0;
   }
   n = _EXPAT_read(fd, p, (_EXPAT_read_req_t)nbytes);
   if (n < 0) {
     tperror(name);
     free(p);
     close(fd);
     return 0;
   }
   if (n != (_EXPAT_read_count_t)nbytes) {
     ftprintf(stderr, T("%s: read unexpected number of bytes\n"), name);
     free(p);
     close(fd);
     return 0;
   }
   processor(p, nbytes, name, arg);
   free(p);
   close(fd);
   return 1;
 }
Index: vendor/expat/dist/xmlwf/unixfilemap.c
===================================================================
--- vendor/expat/dist/xmlwf/unixfilemap.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/unixfilemap.c	(revision 355071)
@@ -1,104 +1,103 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <string.h>
 #include <stdio.h>
 #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;
   void *p;
 
   fd = topen(name, O_RDONLY);
   if (fd < 0) {
     tperror(name);
     return 0;
   }
   if (fstat(fd, &sb) < 0) {
     tperror(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;
   /* mmap fails for zero length files */
   if (nbytes == 0) {
     static const char c = '\0';
     processor(&c, 0, name, arg);
     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);
     return 0;
   }
   processor(p, nbytes, name, arg);
   munmap((void *)p, nbytes);
   close(fd);
   return 1;
 }
Index: vendor/expat/dist/xmlwf/win32filemap.c
===================================================================
--- vendor/expat/dist/xmlwf/win32filemap.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/win32filemap.c	(revision 355071)
@@ -1,125 +1,118 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #define STRICT 1
 #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>
 #include <tchar.h>
 #include "filemap.h"
 
 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;
   DWORD sizeHi;
   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;
   }
   size = GetFileSize(f, &sizeHi);
   if (size == (DWORD)-1) {
     win32perror(name);
     CloseHandle(f);
     return 0;
   }
   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) {
     static const char c = '\0';
     processor(&c, 0, name, arg);
     CloseHandle(f);
     return 1;
   }
   m = CreateFileMapping(f, NULL, PAGE_READONLY, 0, 0, NULL);
   if (m == NULL) {
     win32perror(name);
     CloseHandle(f);
     return 0;
   }
   p = MapViewOfFile(m, FILE_MAP_READ, 0, 0, 0);
   if (p == NULL) {
     win32perror(name);
     CloseHandle(m);
     CloseHandle(f);
     return 0;
   }
-  processor(p, size, name, arg); 
+  processor(p, size, name, arg);
   UnmapViewOfFile(p);
   CloseHandle(m);
   CloseHandle(f);
   return 1;
 }
 
 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);
 }
Index: vendor/expat/dist/xmlwf/xmlfile.c
===================================================================
--- vendor/expat/dist/xmlwf/xmlfile.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/xmlfile.c	(revision 355071)
@@ -1,290 +1,273 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
 #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
+#  ifdef _O_BINARY
+#    define O_BINARY _O_BINARY
+#  else
+#    define O_BINARY 0
+#  endif
 #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'));
 }
 
 #endif /* _WIN32 */
 
 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;
   if (tcsrchr(s, T('/')))
     s = tcsrchr(s, T('/')) + 1;
 #if defined(_WIN32)
   if (tcsrchr(s, T('\\')))
     s = tcsrchr(s, T('\\')) + 1;
 #endif
   tcscpy(s, systemId);
   return *toFree;
 }
 
 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);
   XML_SetBase(entParser, filename);
   filemapRes = filemap(filename, processFile, &args);
   switch (filemapRes) {
   case 0:
     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;
   }
   free(s);
   XML_ParserFree(entParser);
   return result;
 }
 
 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;
     }
   }
   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"),
                filename != NULL ? filename : T("xmlwf"));
       return 0;
     }
     nread = read(fd, buf, READ_SIZE);
     if (nread < 0) {
       tperror(filename != NULL ? filename : T("STDIN"));
       if (filename != NULL)
         close(fd);
       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;
     }
     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);
   free(s);
   XML_ParserFree(entParser);
   return ret;
 }
 
 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;
     args.retPtr = &result;
     args.parser = parser;
     filemapRes = filemap(filename, processFile, &args);
     switch (filemapRes) {
     case 0:
       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;
 }
Index: vendor/expat/dist/xmlwf/xmlfile.h
===================================================================
--- vendor/expat/dist/xmlwf/xmlfile.h	(revision 355070)
+++ vendor/expat/dist/xmlwf/xmlfile.h	(revision 355071)
@@ -1,48 +1,43 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #define XML_MAP_FILE 01
 #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"
+#  define XML_FMT_INT_MOD "l"
 #endif
-#else
-#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);
Index: vendor/expat/dist/xmlwf/xmlmime.c
===================================================================
--- vendor/expat/dist/xmlwf/xmlmime.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/xmlmime.c	(revision 355071)
@@ -1,195 +1,191 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <string.h>
 #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;
   const char *tokStart = 0;
   for (;;) {
     switch (**pp) {
     case '\0':
       if (state == inAtom)
         return tokStart;
       return 0;
     case ' ':
     case '\r':
     case '\t':
     case '\n':
       if (state == inAtom)
         return tokStart;
       break;
     case '(':
       if (state == inAtom)
         return tokStart;
       if (state != inString)
         state++;
       break;
     case ')':
       if (state > init)
         --state;
       else if (state != inString)
         return 0;
       break;
     case ';':
     case '/':
     case '=':
       if (state == inAtom)
         return tokStart;
       if (state == init)
         return (*pp)++;
       break;
     case '\\':
       ++*pp;
       if (**pp == '\0')
         return 0;
       break;
     case '"':
       switch (state) {
       case inString:
         ++*pp;
         return tokStart;
       case inAtom:
         return tokStart;
       case init:
         tokStart = *pp;
         state = inString;
         break;
       }
       break;
     default:
       if (state == init) {
         tokStart = *pp;
         state = inAtom;
       }
       break;
     }
     ++*pp;
   }
   /* not reached */
 }
 
 /* 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'))
       return 0;
   return *key == '\0';
 }
 
 void
-getXMLCharset(const char *buf, char *charset)
-{
+getXMLCharset(const char *buf, char *charset) {
   const char *next, *p;
 
   charset[0] = '\0';
   next = buf;
   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 == ';') {
       p = getTok(&next);
       if (matchkey(p, next, "charset")) {
         p = getTok(&next);
         if (p && *p == '=') {
           p = getTok(&next);
           if (p) {
             char *s = charset;
             if (*p == '"') {
               while (++p != next - 1) {
                 if (*p == '\\')
                   ++p;
                 if (s == charset + CHARSET_MAX - 1) {
                   charset[0] = '\0';
                   break;
                 }
                 *s++ = *p;
               }
               *s++ = '\0';
-            }
-            else {
+            } else {
               if (next - p > CHARSET_MAX - 1)
                 break;
               while (p != next)
                 *s++ = *p++;
               *s = 0;
               break;
             }
           }
         }
         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;
   printf("%s\n", argv[1]);
   getXMLCharset(argv[1], buf);
   printf("charset=\"%s\"\n", buf);
   return 0;
 }
 
 #endif /* TEST */
Index: vendor/expat/dist/xmlwf/xmltchar.h
===================================================================
--- vendor/expat/dist/xmlwf/xmltchar.h	(revision 355070)
+++ vendor/expat/dist/xmlwf/xmltchar.h	(revision 355071)
@@ -1,74 +1,74 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 /* Ensures compile-time constants are consistent */
 #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 */
Index: vendor/expat/dist/xmlwf/xmlwf.c
===================================================================
--- vendor/expat/dist/xmlwf/xmlwf.c	(revision 355070)
+++ vendor/expat/dist/xmlwf/xmlwf.c	(revision 355071)
@@ -1,1138 +1,1126 @@
 /*
                             __  __            _
                          ___\ \/ /_ __   __ _| |_
                         / _ \\  /| '_ \ / _` | __|
                        |  __//  \| |_) | (_| | |_
                         \___/_/\_\ .__/ \__,_|\__|
                                  |_| XML parser
 
    Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
    Copyright (c) 2000-2017 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.
 */
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stddef.h>
 #include <string.h>
 
 #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 */
 typedef struct NotationList {
   struct NotationList *next;
   const XML_Char *notationName;
   const XML_Char *systemId;
   const XML_Char *publicId;
 } NotationList;
 
 typedef struct xmlwfUserData {
   FILE *fp;
   NotationList *notationListHead;
   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) {
     case T('&'):
       fputts(T("&amp;"), fp);
       break;
     case T('<'):
       fputts(T("&lt;"), fp);
       break;
     case T('>'):
       fputts(T("&gt;"), fp);
       break;
 #ifdef W3C14N
     case 13:
       fputts(T("&#xD;"), fp);
       break;
 #else
     case T('"'):
       fputts(T("&quot;"), fp);
       break;
     case 9:
     case 10:
     case 13:
       ftprintf(fp, T("&#%d;"), *s);
       break;
 #endif
     default:
       puttc(*s, fp);
       break;
     }
   }
 }
 
 static void
-attributeValue(FILE *fp, const XML_Char *s)
-{
+attributeValue(FILE *fp, const XML_Char *s) {
   puttc(T('='), fp);
   puttc(T('"'), fp);
   assert(s);
   for (;;) {
     switch (*s) {
     case 0:
     case NSSEP:
       puttc(T('"'), fp);
       return;
     case T('&'):
       fputts(T("&amp;"), fp);
       break;
     case T('<'):
       fputts(T("&lt;"), fp);
       break;
     case T('"'):
       fputts(T("&quot;"), fp);
       break;
 #ifdef W3C14N
     case 9:
       fputts(T("&#x9;"), fp);
       break;
     case 10:
       fputts(T("&#xA;"), fp);
       break;
     case 13:
       fputts(T("&#xD;"), fp);
       break;
 #else
     case T('>'):
       fputts(T("&gt;"), fp);
       break;
     case 9:
     case 10:
     case 13:
       ftprintf(fp, T("&#%d;"), *s);
       break;
 #endif
     default:
       puttc(*s, fp);
       break;
     }
     s++;
   }
 }
 
 /* Lexicographically comparing UTF-8 encoded attribute values,
 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;
   puttc(T('<'), fp);
   fputts(name, fp);
 
   p = atts;
   while (*p)
     ++p;
   nAtts = (int)((p - atts) >> 1);
   if (nAtts > 1)
     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
   while (*atts) {
     puttc(T(' '), fp);
     fputts(*atts++, fp);
     attributeValue(fp, *atts);
     atts++;
   }
   puttc(T('>'), fp);
 }
 
 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);
   fputts(name, fp);
   puttc(T('>'), fp);
 }
 
 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);
   int sep2 = (tcsrchr(att1, NSSEP) != 0);
   if (sep1 != sep2)
     return sep1 - sep2;
   return tcscmp(att1, att2);
 }
 
 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;
   FILE *fp = ((XmlwfUserData *)userData)->fp;
   const XML_Char *sep;
   puttc(T('<'), fp);
 
   sep = tcsrchr(name, NSSEP);
   if (sep) {
     fputts(T("n1:"), fp);
     fputts(sep + 1, fp);
     fputts(T(" xmlns:n1"), fp);
     attributeValue(fp, name);
     nsi = 2;
-  }
-  else {
+  } else {
     fputts(name, fp);
     nsi = 1;
   }
 
   p = atts;
   while (*p)
     ++p;
   nAtts = (int)((p - atts) >> 1);
   if (nAtts > 1)
     qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
   while (*atts) {
     name = *atts++;
     sep = tcsrchr(name, NSSEP);
     puttc(T(' '), fp);
     if (sep) {
       ftprintf(fp, T("n%d:"), nsi);
       fputts(sep + 1, fp);
-    }
-    else
+    } else
       fputts(name, fp);
     attributeValue(fp, *atts);
     if (sep) {
       ftprintf(fp, T(" xmlns:n%d"), nsi++);
       attributeValue(fp, name);
     }
     atts++;
   }
   puttc(T('>'), fp);
 }
 
 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);
   puttc(T('/'), fp);
   sep = tcsrchr(name, NSSEP);
   if (sep) {
     fputts(T("n1:"), fp);
     fputts(sep + 1, fp);
-  }
-  else
+  } else
     fputts(name, fp);
   puttc(T('>'), fp);
 }
 
 #ifndef W3C14N
 
 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);
   fputts(target, fp);
   puttc(T(' '), fp);
   fputts(data, fp);
   puttc(T('?'), fp);
   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;
 
   /* Get the length of the string, including terminator */
   while (s[count++] != 0) {
     /* Do nothing */
   }
   numBytes = count * sizeof(XML_Char);
   result = malloc(numBytes);
   if (result == NULL)
     return NULL;
   memcpy(result, s, numBytes);
   return result;
 }
 
 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) {
     NotationList *next = notationListHead->next;
     free((void *)notationListHead->notationName);
     free((void *)notationListHead->systemId);
     free((void *)notationListHead->publicId);
     free(notationListHead);
     notationListHead = next;
   }
   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;
     if (*xs > *xt)
       return 1;
     xs++;
     xt++;
   }
   if (*xs < *xt)
     return -1;
   if (*xs > *xt)
     return 1;
   return 0;
 }
 
 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;
   NotationList *p;
   int i;
 
   /* How many notations do we have? */
   for (p = data->notationListHead; p != NULL; p = p->next)
     notationCount++;
   if (notationCount == 0) {
     /* Nothing to report */
     free((void *)data->currentDoctypeName);
     data->currentDoctypeName = NULL;
     return;
   }
 
   notations = malloc(notationCount * sizeof(NotationList *));
   if (notations == NULL) {
     fprintf(stderr, "Unable to sort notations");
     freeNotations(data);
     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);
 
   /* Output the DOCTYPE header */
   fputts(T("<!DOCTYPE "), data->fp);
   fputts(data->currentDoctypeName, data->fp);
   fputts(T(" [\n"), data->fp);
 
   /* Now the NOTATIONs */
   for (i = 0; i < notationCount; i++) {
     fputts(T("<!NOTATION "), data->fp);
     fputts(notations[i]->notationName, data->fp);
     if (notations[i]->publicId != NULL) {
       fputts(T(" PUBLIC '"), data->fp);
       fputts(notations[i]->publicId, data->fp);
       puttc(T('\''), data->fp);
       if (notations[i]->systemId != NULL) {
         puttc(T(' '), data->fp);
         puttc(T('\''), data->fp);
         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);
     }
     puttc(T('>'), data->fp);
     puttc(T('\n'), data->fp);
   }
 
   /* Finally end the DOCTYPE */
   fputts(T("]>\n"), data->fp);
 
   free(notations);
   freeNotations(data);
   free((void *)data->currentDoctypeName);
   data->currentDoctypeName = NULL;
 }
 
 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 */
   }
   entry->notationName = xcsdup(notationName);
   if (entry->notationName == NULL) {
     fputs(errorMessage, stderr);
     free(entry);
     return;
   }
   if (systemId != NULL) {
     entry->systemId = xcsdup(systemId);
     if (entry->systemId == NULL) {
       fputs(errorMessage, stderr);
       free((void *)entry->notationName);
       free(entry);
       return;
     }
-  }
-  else {
+  } else {
     entry->systemId = NULL;
   }
   if (publicId != NULL) {
     entry->publicId = xcsdup(publicId);
     if (entry->publicId == NULL) {
       fputs(errorMessage, stderr);
       free((void *)entry->systemId); /* Safe if it's NULL */
       free((void *)entry->notationName);
       free(entry);
       return;
     }
-  }
-  else {
+  } else {
     entry->publicId = NULL;
   }
 
   entry->next = data->notationListHead;
   data->notationListHead = entry;
 }
 
 #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)
     idAttPtr = 0;
   else
     idAttPtr = atts + idAttIndex;
 
   ftprintf(fp, T("<starttag name=\"%s\""), name);
   metaLocation(parser);
   if (*atts) {
     fputts(T(">\n"), fp);
     do {
       ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
       characterData(data, atts[1], (int)tcslen(atts[1]));
       if (atts >= specifiedAttsEnd)
         fputts(T("\" defaulted=\"yes\"/>\n"), fp);
       else if (atts == idAttPtr)
         fputts(T("\" id=\"yes\"/>\n"), fp);
       else
         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);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   characterData(usrData, data, (int)tcslen(data));
   puttc(T('"'), fp);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   characterData(usrData, data, (int)tcslen(data));
   puttc(T('"'), fp);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   characterData(data, s, len);
   puttc(T('"'), fp);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   metaLocation(parser);
   fputts(T("/>\n"), fp);
 }
 
 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);
   if (systemId) {
     fputts(T(" system=\""), fp);
     characterData(data, systemId, (int)tcslen(systemId));
     puttc(T('"'), fp);
   }
   metaLocation(parser);
   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);
     fputts(T(" system=\""), fp);
     characterData(data, systemId, (int)tcslen(systemId));
     puttc(T('"'), fp);
     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);
     fputts(T(" system=\""), fp);
     characterData(data, systemId, (int)tcslen(systemId));
     puttc(T('"'), fp);
     metaLocation(parser);
     fputts(T("/>\n"), fp);
   }
 }
 
 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);
   if (prefix)
     ftprintf(fp, T(" prefix=\"%s\""), prefix);
   if (uri) {
     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();
   while ((ch = *s) != 0) {
     if (ch == '/'
 #if defined(_WIN32)
         || ch == '\\'
 #endif
-        )
+    )
       prog = s + 1;
     ++s;
   }
   ftprintf(stdout, T("%s using %s\n"), prog, XML_ExpatVersion());
   if (features != NULL && features[0].feature != XML_FEATURE_END) {
     int i = 1;
     ftprintf(stdout, T("%s"), features[0].name);
     if (features[0].value)
       ftprintf(stdout, T("=%ld"), features[0].value);
     while (features[i].feature != XML_FEATURE_END) {
       ftprintf(stdout, T(", %s"), features[i].name);
       if (features[i].value)
         ftprintf(stdout, T("=%ld"), features[i].value);
       ++i;
     }
     ftprintf(stdout, T("\n"));
   }
 }
 
 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);
 }
 
 #if defined(__MINGW32__) && defined(XML_UNICODE)
 /* Silence warning about missing prototype */
 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;
   unsigned processFlags = XML_MAP_FILE;
   int windowsCodePages = 0;
   int outputType = 0;
   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;
   j = 0;
   while (i < argc) {
     if (j == 0) {
       if (argv[i][0] != T('-'))
         break;
       if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
         i++;
         break;
       }
       j++;
     }
     switch (argv[i][j]) {
     case T('r'):
       processFlags &= ~XML_MAP_FILE;
       j++;
       break;
     case T('s'):
       requireStandalone = 1;
       j++;
       break;
     case T('n'):
       useNamespaces = 1;
       j++;
       break;
     case T('p'):
       paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
       /* fall through */
     case T('x'):
       processFlags |= XML_EXTERNAL_ENTITIES;
       j++;
       break;
     case T('w'):
       windowsCodePages = 1;
       j++;
       break;
     case T('m'):
       outputType = 'm';
       j++;
       break;
     case T('c'):
       outputType = 'c';
       useNamespaces = 0;
       j++;
       break;
     case T('t'):
       outputType = 't';
       j++;
       break;
     case T('N'):
       requiresNotations = 1;
       j++;
       break;
     case T('d'):
       if (argv[i][j + 1] == T('\0')) {
         if (++i == argc)
           usage(argv[0], 2);
         outputDir = argv[i];
-      }
-      else
+      } else
         outputDir = argv[i] + j + 1;
       i++;
       j = 0;
       break;
     case T('e'):
       if (argv[i][j + 1] == T('\0')) {
         if (++i == argc)
           usage(argv[0], 2);
         encoding = argv[i];
-      }
-      else
+      } else
         encoding = argv[i] + j + 1;
       i++;
       j = 0;
       break;
     case T('h'):
       usage(argv[0], 0);
       return 0;
     case T('v'):
       showVersion(argv[0]);
       return 0;
     case T('\0'):
       if (j > 1) {
         i++;
         j = 0;
         break;
       }
       /* fall through */
     default:
       usage(argv[0], 2);
     }
   }
   if (i == argc) {
     useStdin = 1;
     processFlags &= ~XML_MAP_FILE;
     i--;
   }
   for (; i < argc; i++) {
     XML_Char *outName = 0;
     int result;
     XML_Parser parser;
     if (useNamespaces)
       parser = XML_ParserCreateNS(encoding, NSSEP);
     else
       parser = XML_ParserCreate(encoding);
 
     if (! parser) {
       tperror(T("Could not instantiate parser"));
       exit(1);
     }
 
     if (requireStandalone)
       XML_SetNotStandaloneHandler(parser, notStandalone);
     XML_SetParamEntityParsing(parser, paramEntityParsing);
     if (outputType == 't') {
       /* This is for doing timings; this gives a more realistic estimate of
          the parsing time. */
       outputDir = 0;
       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;
             delim = winDelim;
           }
         }
 #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);
       }
       setvbuf(userData.fp, NULL, _IOFBF, 16384);
 #ifdef XML_UNICODE
       puttc(0xFEFF, userData.fp);
 #endif
       XML_SetUserData(parser, &userData);
       switch (outputType) {
       case 'm':
         XML_UseParserAsHandlerArg(parser);
         XML_SetElementHandler(parser, metaStartElement, metaEndElement);
         XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
         XML_SetCommentHandler(parser, metaComment);
         XML_SetCdataSectionHandler(parser, metaStartCdataSection,
                                    metaEndCdataSection);
         XML_SetCharacterDataHandler(parser, metaCharacterData);
         XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl,
                                   metaEndDoctypeDecl);
         XML_SetEntityDeclHandler(parser, metaEntityDecl);
         XML_SetNotationDeclHandler(parser, metaNotationDecl);
         XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl,
                                     metaEndNamespaceDecl);
         metaStartDocument(parser);
         break;
       case 'c':
         XML_UseParserAsHandlerArg(parser);
         XML_SetDefaultHandler(parser, markup);
         XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
         XML_SetCharacterDataHandler(parser, defaultCharacterData);
         XML_SetProcessingInstructionHandler(parser,
                                             defaultProcessingInstruction);
         break;
       default:
         if (useNamespaces)
           XML_SetElementHandler(parser, startElementNS, endElementNS);
         else
           XML_SetElementHandler(parser, startElement, endElement);
         XML_SetCharacterDataHandler(parser, characterData);
 #ifndef W3C14N
         XML_SetProcessingInstructionHandler(parser, processingInstruction);
         if (requiresNotations) {
           XML_SetDoctypeDeclHandler(parser, startDoctypeDecl, endDoctypeDecl);
           XML_SetNotationDeclHandler(parser, notationDecl);
         }
 #endif /* not W3C14N */
         break;
       }
     }
     if (windowsCodePages)
       XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
     result = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);
     if (outputDir) {
       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;
 }
Index: vendor/expat/dist/xmlwf/xmlwf_helpgen.py
===================================================================
--- vendor/expat/dist/xmlwf/xmlwf_helpgen.py	(nonexistent)
+++ vendor/expat/dist/xmlwf/xmlwf_helpgen.py	(revision 355071)
@@ -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()

Property changes on: vendor/expat/dist/xmlwf/xmlwf_helpgen.py
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Index: vendor/expat/dist/xmlwf/xmlwf_helpgen.sh
===================================================================
--- vendor/expat/dist/xmlwf/xmlwf_helpgen.sh	(nonexistent)
+++ vendor/expat/dist/xmlwf/xmlwf_helpgen.sh	(revision 355071)
@@ -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"),'

Property changes on: vendor/expat/dist/xmlwf/xmlwf_helpgen.sh
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+FreeBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property