+!! !!

+!! If your business relies on Expat beyond January 2027, please consider !!

+!! funding the maintenance of Expat to ensure its health and security for !!

+!! you and others. Thank you! !!

+!! !!

+!! Sebastian Pipping -- Berlin, 2026-09-22 !!

+Release 2.8.5 Tue September 22 2026

+ Security fixes:

+ #1282 CVE-2026-93990 -- Reject high surrogates not followed by a

+ low surrogate during UTF-16 decoding; previously, malformed

+ UTF-16 could be smuggled into the application using Expat

+ and could cause arbitrary damage there, depending on how

+ malformed UTF-16 was handled inside the application;

+ validation was not their job but Expat's. This is similar

+ to past vulnerability CVE-2022-25235.

+ Upstream CVSS 3.1 vector:

+ AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (CVSS score: 9.8)

+

+///////////////////////////////////////////////////////////////////////////////

+// The next release will drop two (disabled-by-default) features: //

+// //

+// - ATTR_INFO (-DXML_ATTR_INFO, -DEXPAT_ATTR_INFO, --enable-xml-attr-info, //

+// function XML_GetAttributeInfo, struct XML_AttrInfo) //

+// - MIN_SIZE (-DXML_MIN_SIZE, -DEXPAT_MIN_SIZE) //

+// //

+// If you need them in 2026 and beyond, please share your scenario at //

+// GitHub issues #1370 (for ATTR_INFO) and/or #1379 (for MIN_SIZE). Thanks! //

+///////////////////////////////////////////////////////////////////////////////

+

+ Bug fixes:

+ #1346 lib: Fix OOM-related memory leak on a failed overflow check

+ #1371 lib: Fix memory alignment for architectures with 128bit

+ pointers like CHERI-RISC-V

+ #1367 xmlwf: Handle errors when closing output files

+

+ Other changes:

+ #1354 lib: Reject an XML declaration version other than `1.[0-9]+`

+ (which is less strict than XML 1.0r4 (fourth edition)

+ and matches XML 1.0r5 (fifth edition))

+ #1362 lib: Make Clang, GCC and MSVC warn about use of function

+ XML_SetHashSalt that is deprecated since Expat 2.8.0

+ #1357 lib: Drop internal macros FASTCALL, PTRCALL, PTRFASTCALL

+ #1367 xmlwf: Document that with `-k` the last error determines the

+ xmlwf exit code in `--help` output

+ #1367 xmlwf: Make exit code 3 documentation match exit code 2 more

+ closely in `--help` output

+ #1352 #1353 CMake|Windows: Refrain from adding `/source-charset:utf-8`

+ for MSVC

+ #1366 #1374 Autotools: Be explicit about the minimum required version of

+ GNU Automake, currently version 1.13 of 2012-12-28

+ #1351 Autotools|macOS: Sync CMake templates with CMake 4.4.3

+ #1349 Replace some internal use of XML_Bool with standard bool

+ #1364 tests: Propagate xmltest.sh failures via exit status

+ #1360 tests|xmlwf: Add `#include "expat_config.h"` where missing

+ #1355 tests: Start covering hash table operation

+ #1350 #1369 tests: Drop __cplusplus leftovers

+ #1378 tests: Fix tail pointer when unlinking the last tracked

+ allocation

+ #1376 docs: Emphasize that XML_StopParser is not immediate

+ #1381 docs: Sync XML_FeatureEnum value list in doc/reference.html

+ #1356 #1361 Version info bumped from 13:4:12 (libexpat*.so.1.12.4)

+ to 13:5:12 (libexpat*.so.1.12.5); see https://verbump.de/

+ for what these numbers do

+

+ Infrastructure:

+ #1347 Add missing .gitignore entries

+ #1360 CI: Detect missing `#include "expat_config.h"`

+ #1368 CI: Bump MinGW Clang from 23.0.1 to 23.1.1

+ #1377 CI: Bump Fil-C from 0.684 to 0.685

+ #1380 CI: Bump Cppcheck from 2.21.0 to 2.22.0

+ #1372 CI: Extract helper script `apply-htmltidy.sh`

+ #1366 #1374 Autotools: Start to also produce .tar.bz3 release tarballs

+

+ Special thanks to:

+ Afonso Januário

+ Braian Plaku

+ Florian Schmaus

+ Huang Wenbin

+ Kamila Szewczyk

+ Kartik Kenchi

+ Leo Camus

+ Matthew Fernandez

+ Stan Ulbrych

+ and

+ City of Munich Open Source Sabbatical

+

+Release 2.8.4 Mon August 31 2026

+ Security fixes:

+ #1321 #1331 CVE-2026-66046, CVE-2026-76641 -- Fix quadratic runtime from

+ "attribute isCdata lookups" that allowed denial of service

+ attacks through moderately sized crafted XML input

+ (CWE-407).

+ The vulnerability is closely related to past CVE-2026-45186

+ that was fixed with Expat 2.8.1.

+ Please note that a layer of compression around XML can

+ significantly reduce the minimum attack payload size.

+ Upstream CVSS 3.1 vector:

+ AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H (CVSS score: 7.5)

+ (Note the "AV:N" for network/remote.)

+ #1322 CVE-2026-76957 -- Protect custom encoding callbacks from

+ parser re-entry. The vulnerability is closely related to

+ past issues CVE-2026-50219, CVE-2026-56131 and

+ CVE-2026-56412 that were all fixed with Expat 2.8.2.

+ #1326 CVE-2026-76956 -- Fix inverted getentropy() return handling

+ Allows for hash flooding denial of services in

+ configurations where getentropy is configured or detected

+ as the only high quality entropy extractor.

+ Upstream CVSS 3.1 vector:

+ AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H (CVSS score: 5.9)

+ (Note the "AV:N" for network/remote.)

+

+ Other changes:

+ #1332 #1333 CMake: Only add `/source-charset:utf-8` when `/utf-8` is not

+ present

+ #1315 lib: Resolve (currently unreachable) undefined behavior from

+ overshifting a signed int to the left

+ #1325 #1334 lib: Support read-only hash table lookup with keys that are

+ not zero-terminated

+ #1340 lib: Use a C99 bool for `ENTITY.open`

+ #1319 Fix typo in comment

+ #1320 Sync file headers

+ #1328 #1329 Version info bumped from 13:3:12 (libexpat*.so.1.12.3)

+ to 13:4:12 (libexpat*.so.1.12.4); see https://verbump.de/

+ for what these numbers do

+

+ Infrastructure:

+ #1317 #1335 CI: Cover compilation and execution with Fil-C

+ #1337 CI: Cover compilation and execution on riscv64

+ #1338 CI: Cover compilation and execution with Clang-based MinGW

+ #1339 CI: Cover compilation and execution on (big-endian) s390x

+ #1316 CI: Run test suite with musl, also

+ #1336 CI: Bump WASI SDK from 33 to 34

+ #1345 CI: Bump Clang from 22 to 23

+

+ Special thanks to:

+ Alberto Maschietto

+ Alexander Bluhm

+ Berkay Eren Ürün

+ Darren Carreras

+ Fabian Wahle (Hap Security)

+ Matteo Forzan

+ Matthew Fernandez

+ Sorrashut Kaewtaworn

+ Wade Sparks III

+ Zeyou Liu

+ and

+ City of Munich Open Source Sabbatical

+ Moonshot AI

+ VulnCheck

+ Z.ai

+

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__post_remove_distdir = \

+ $(am__is_gnu_make) || rm -f am__distdir.tar; \

+ $(am__remove_distdir)

+am__ensure_distdir_tar = \

+ test -f am__distdir.tar || $(MAKE) $(AM_MAKEFLAGS) am__distdir.tar

+am__dist_compress_failed = \

+ am__rc=$$?; rm -f $$am__archive am__distdir.tar; exit $$am__rc

+# Exists only to be overridden by the user if desired.

+AM_DIST_TAR_IGNORE_STDERR = $(am__tar_ignore_stderr)

+DIST_ARCHIVES = $(distdir).tar.gz $(distdir).tar.bz2 \

+ $(distdir).tar.bz3 $(distdir).tar.lz $(distdir).tar.xz

+DIST_TARGETS = am--dist-lzip am--dist-xz am--dist-bzip2 am--dist-bzip3 \

+ am--dist-gzip

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+

+am__distdir.tar: distdir

+ am__distdir="$(distdir)"; \

+ am__tar_msg=`tardir=$$am__distdir && $(am__tar) 2>&1 >am__distdir.tar`; \

+ am__tar_rc=$$?; \

+ test -z "$$am__tar_msg" || { printf '%s\n' "$$am__tar_msg" >&2; \

+ test x"$(AM_DIST_TAR_IGNORE_STDERR)" = xyes || am__tar_rc=1; }; \

+ test $$am__tar_rc -eq 0 || { rm -f am__distdir.tar; \

+ echo "$(distdir).tar: cannot create the distribution archive" >&2; exit 1; }

+

+.INTERMEDIATE: am__distdir.tar

+dist-gzip: am--dist-gzip

+am--dist-gzip: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.gz; \

+ eval GZIP= gzip $(GZIP_ENV) -c <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-bzip2: am--dist-bzip2

+am--dist-bzip2: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.bz2; \

+ BZIP2=$${BZIP2--9} bzip2 -c <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-bzip3: am--dist-bzip3

+am--dist-bzip3: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.bz3; \

+ bzip3 -c <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-lzip: am--dist-lzip

+am--dist-lzip: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.lz; \

+ lzip -c $${LZIP_OPT--9} <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-xz: am--dist-xz

+am--dist-xz: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.xz; \

+ XZ_OPT=$${XZ_OPT--e} xz -c <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-zstd: am--dist-zstd

+am--dist-zstd: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.zst; \

+ zstd -c $${ZSTD_CLEVEL-$${ZSTD_OPT--19}} <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-tarZ: am--dist-tarZ

+ $(am__post_remove_distdir)

+am--dist-tarZ: am__distdir.tar

+ @$(am__ensure_distdir_tar)

+ am__archive=$(distdir).tar.Z; \

+ compress -c <am__distdir.tar >$$am__archive \

+ || { $(am__dist_compress_failed); }

+dist-shar: am--dist-shar

+ $(am__post_remove_distdir)

+am--dist-shar: distdir

+ shar $(distdir) >$(distdir).shar || { rm -f $(distdir).shar; exit 1; }

+ eval GZIP= gzip $(GZIP_ENV) -f $(distdir).shar

+dist-zip: am--dist-zip

+ $(am__post_remove_distdir)

+am--dist-zip: distdir

+ $(MAKE) $(AM_MAKEFLAGS) $(DIST_TARGETS)

+ case "$(DIST_ARCHIVES)" in \

+ am__distdir="$(distdir)"; \

+ am__distarchives="$(DIST_ARCHIVES)"; \

+ test -d "$$am__distdir/_build" || exit 0; \

+ dc_install_base=`$(am__cd) "$$am__distdir/_inst" && pwd | sed -e 's,^[^:\\/]:[\\/],/,'` \

+ && $(am__cd) "$$am__distdir/_build/sub" \

+ && rm -rf $$am__distarchives \

+ list="$(DIST_ARCHIVES)"; for i in $$list; do echo $$i; done) | \

+ am--dist-bzip2 am--dist-bzip3 am--dist-gzip am--dist-lzip \

+ am--dist-shar am--dist-tarZ am--dist-xz am--dist-zip \

+ am--dist-zstd am--refresh check check-am clean clean-cscope \

+ clean-generic clean-libtool cscope cscopelist-am ctags \

+ ctags-am dist dist-all dist-bzip2 dist-bzip3 dist-gzip \

+ dist-lzip dist-shar dist-tarZ dist-xz dist-zip dist-zstd \

+ 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 \

+# Expat, Release 2.8.5

+

+dnl NOTE: Macro `AM_OPTIONAL_AUTOMAKE` is available with Automake >=1.19

+dnl and serves as a proxy for robust Automake >=1.19 detection here.

+dnl `dist-bzip3` was introduced with Automake 1.18 already but there

+dnl is no robust way of checking precisely for Automake >=1.18.

+dnl Automake >=1.13 is needed for (1) our use of LOG_DRIVER and

+dnl (2) making it work without asking for parallel tests, explicitly.

+m4_ifdef([AM_OPTIONAL_AUTOMAKE], [

+ AM_INIT_AUTOMAKE([1.19 dist-bzip2 dist-bzip3 dist-lzip dist-xz foreign subdir-objects])

+

+ dnl NOTE: Without this dummy call in the file the `m4_ifdef` above never hits true.

+ AM_OPTIONAL_AUTOMAKE([])

+], [

+ AM_INIT_AUTOMAKE([1.13 dist-bzip2 dist-lzip dist-xz foreign subdir-objects])

+])

+LIBREVISION=5 # with

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign doc/Makefile'; \

+ $(AUTOMAKE) --foreign doc/Makefile

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ The Expat XML Parser <small>Release 2.8.5</small>

+ Stops parsing as soon as possible, 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.

+ </p>

+

+ <p>

+ <strong>Note:</strong> Some call-backs may still follow because they would

+ otherwise get lost, including

+ /* Added in Expat 2.0.0. */

+ /* Added in Expat 2.0.1. */

+ XML_FEATURE_LARGE_SIZE,

+ /* Added in Expat 2.1.0. */

+ XML_FEATURE_ATTR_INFO,

+ /* Added in Expat 2.4.0. */

+ XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,

+ XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,

+ /* Added in Expat 2.6.0. */

+ XML_FEATURE_GE,

+ /* Added in Expat 2.7.2. */

+ XML_FEATURE_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT,

+ XML_FEATURE_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT,

+.TH XMLWF 1 "September 22, 2026" "" ""

+ <!ENTITY dhdate "<date>September 22, 2026</date>">

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign examples/Makefile'; \

+ $(AUTOMAKE) --foreign examples/Makefile

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ -e '# Filter out "unhandled instruction" lines from AddressSanitizer' \

+ -e '/^==[0-9]\+==interception_win: unhandled instruction at /d' \

+ \

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+ const uint8_t entropy[16] = {0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,

+ 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41};

+ XML_SetHashSalt16Bytes(parser, entropy);

+#include <string.h>

+static unsigned char hash_key_1[16] = "FUZZING IS FUN?";

+static unsigned char hash_key_2[16] = "FUZZING IS FUN!";

+ // The salt is 16 bytes and siphash24 produces 8, so the input is hashed

+ // under two keys.

+ const uint64_t first = siphash24(data, size, sip_keyof(hash_key_1));

+ const uint64_t second = siphash24(data, size, sip_keyof(hash_key_2));

+ uint8_t entropy[16];

+ memcpy(entropy, &first, sizeof(first));

+ memcpy(entropy + sizeof(first), &second, sizeof(second));

+ XML_SetHashSalt16Bytes(p, entropy);

+static unsigned char hash_key_1[16] = "FUZZING IS FUN?";

+static unsigned char hash_key_2[16] = "FUZZING IS FUN!";

+ // The salt is 16 bytes and siphash24 produces 8, so the input is hashed

+ // under two keys.

+ const uint64_t first = siphash24(data, size, sip_keyof(hash_key_1));

+ const uint64_t second = siphash24(data, size, sip_keyof(hash_key_2));

+ uint8_t entropy[16];

+ memcpy(entropy, &first, sizeof(first));

+ memcpy(entropy + sizeof(first), &second, sizeof(second));

+ XML_SetHashSalt16Bytes(p, entropy);

+ hash_table.h \

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ hash_table.h \

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign lib/Makefile'; \

+ $(AUTOMAKE) --foreign lib/Makefile

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+ Please use XML_SetHashSalt16Bytes instead.

+XML_ATTR_DEPRECATED("please use XML_SetHashSalt16Bytes instead")

+ /* Added in Expat 2.0.0. */

+ /* Added in Expat 2.0.1. */

+ /* Added in Expat 2.1.0. */

+# define XML_MICRO_VERSION 5

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+/* Marks a function that Expat still provides but that callers should move off

+ of. */

+# if defined(__clang__) || defined(__GNUC__)

+# define XML_ATTR_DEPRECATED(message) \

+ __attribute__((__deprecated__(message)))

+# elif defined(_MSC_VER)

+# define XML_ATTR_DEPRECATED(message) __declspec(deprecated(message))

+# else

+# define XML_ATTR_DEPRECATED(message) // empty i.e. no deprecation

+# endif

+

+/* Hash table related internal API

+ __ __ _

+ ___\ \/ /_ __ __ _| |_

+ / _ \\ /| '_ \ / _` | __|

+ | __// \| |_) | (_| | |_

+ \___/_/\_\ .__/ \__,_|\__|

+ |_| XML parser

+

+ Copyright (c) 2026 Sebastian Pipping <sebastian@pipping.org>

+ 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.

+

+ SPDX-License-Identifier: MIT

+*/

+

+#if ! defined(HASH_TABLE_H)

+# define HASH_TABLE_H 1

+

+# include "expat.h" // for XML_Bool, XML_Parser

+# include "internal.h" // for XML_NONTESTING_STATIC

+

+# include <stddef.h> // for size_t

+

+typedef const XML_Char *KEY;

+

+typedef struct {

+ KEY name;

+} NAMED;

+

+typedef struct {

+ NAMED **v;

+ unsigned char power;

+ size_t size;

+ size_t used;

+ XML_Parser parser;

+} HASH_TABLE;

+

+typedef struct {

+ NAMED **p;

+ NAMED **end;

+} HASH_TABLE_ITER;

+

+XML_NONTESTING_STATIC NAMED *lookupWithLength(XML_Parser parser,

+ HASH_TABLE *table, KEY name,

+ size_t nameLen,

+ size_t createSize);

+XML_NONTESTING_STATIC NAMED *lookup(XML_Parser parser, HASH_TABLE *table,

+ KEY name, size_t createSize);

+

+XML_NONTESTING_STATIC void hashTableInit(HASH_TABLE *table, XML_Parser parser);

+XML_NONTESTING_STATIC void hashTableClear(HASH_TABLE *table);

+XML_NONTESTING_STATIC void hashTableDestroy(HASH_TABLE *table);

+XML_NONTESTING_STATIC void hashTableIterInit(HASH_TABLE_ITER *iter,

+ const HASH_TABLE *table);

+XML_NONTESTING_STATIC NAMED *hashTableIterNext(HASH_TABLE_ITER *iter);

+

+XML_NONTESTING_STATIC XML_Bool keyeq(KEY s1, size_t s1len, KEY s2);

+XML_NONTESTING_STATIC size_t keylen(KEY s);

+

+#endif // ! defined(HASH_TABLE_H)

+ Copyright (c) 2026 Matthew Wozniczka <mattheww@simba.com>

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+ Copyright (c) 2026 Florian Schmaus <florian.schmaus@codasip.com>

+#if ! defined(INTERNAL_H)

+# define INTERNAL_H 1

+# ifndef XML_MIN_SIZE

+# if ! defined(inline)

+# ifdef __GNUC__

+# define inline __inline

+# endif /* __GNUC__ */

+# endif

+# endif /* XML_MIN_SIZE */

+# if ! defined(XML_NONTESTING_STATIC)

+# if defined(XML_TESTING)

+# define XML_NONTESTING_STATIC // empty i.e. not static

+# else

+# define XML_NONTESTING_STATIC static

+# endif

+# endif

+

+# include <limits.h> // ULONG_MAX

+# include <stddef.h> // size_t

+# if defined(_WIN32) \

+ && (! defined(__USE_MINGW_ANSI_STDIO) \

+ || (1 - __USE_MINGW_ANSI_STDIO - 1 == 0))

+# define EXPAT_FMT_LLX(midpart) "%" midpart "I64x"

+# define EXPAT_FMT_ULL(midpart) "%" midpart "I64u"

+# if defined(_WIN64) // Note: modifiers "td" and "zu" do not work for MinGW

+# define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "I64d"

+# define EXPAT_FMT_SIZE_T(midpart) "%" midpart "I64u"

+# else

+# define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"

+# define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"

+# endif

+# include <inttypes.h> // PRIdPTR, PRIuPTR

+# define EXPAT_FMT_LLX(midpart) "%" midpart "llx"

+# define EXPAT_FMT_ULL(midpart) "%" midpart "llu"

+# define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart PRIdPTR

+# define EXPAT_FMT_SIZE_T(midpart) "%" midpart PRIuPTR

+# ifndef UNUSED_P

+# define UNUSED_P(p) (void)p

+# endif

+# define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT \

+ 100.0f

+# define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT \

+ 8388608 // 8 MiB, 2^23

+# define EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT 100.0f

+# define EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT \

+ 67108864 // 64 MiB, 2^26

+union expat_align {

+ long long l;

+ void *p;

+};

+# define EXPAT_MALLOC_ALIGNMENT sizeof(union expat_align)

+# define EXPAT_MALLOC_PADDING ((EXPAT_MALLOC_ALIGNMENT) - sizeof(size_t))

+# include "expat.h" // so we can use type XML_Parser below

+# if defined(XML_GE) && XML_GE == 1

+# endif

+# if ! defined(XML_TESTING)

+# endif

+# if defined(XML_TESTING)

+

+int xmlSetHashSalt(XML_Parser parser, unsigned long hash_salt);

+

+# endif

+#endif // not defined INTERNAL_H

+ const bool success = (getentropy(target, count) == 0);

+/* 0864fe2d216f47b742263b698bc051c865b342e8b820e42c234717098ea507e3 (2.8.5+)

+ Copyright (c) 2026 Darren Carreras <carrerasdarren@gmail.com>

+ Copyright (c) 2026 Alberto Maschietto <albertomaschietto9@gmail.com>

+ Copyright (c) 2026 Zeyou Liu <zeyouliu@tencent.com>

+ Copyright (c) 2026 Stan Ulbrych <stan@python.org>

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+#include "hash_table.h"

+ bool open;

+ bool hasMore; /* true if entity has not been completely processed */

+ /* An entity can be open while being already completely processed (!hasMore).

+ The reason is the delayed closing of entities until their inner

+ bool is_param;

+ bool is_internal; /* true if declared in internal subset outside PE */

+ bool maybeTokenized;

+ bool xmlns;

+// This structure allows mapping attribute names to instances of

+// `DEFAULT_ATTRIBUTE`.

+typedef struct {

+ // Member `name` goes first to make this structure compatible with structure

+ // `NAMED` (further up), which is needed to support use of structure

+ // `NAME_AND_DEFAULT_ATTRIBUTE` in a hash table as implemented by function

+ // `lookup` (further down).

+ const XML_Char *name;

+ // We would store a `DEFAULT_ATTRIBUTE *` here but the backing array

+ // can be reallocated which would invalidate the pointer. Using an index

+ // into the array instead, avoids that problem.

+ size_t attIndex;

+ // This is set to `false` by function `lookup`.

+ bool initialized;

+} NAME_AND_DEFAULT_ATTRIBUTE;

+

+ HASH_TABLE defaultAttForName;

+ bool paramEntityRead;

+ bool in_eldecl;

+ bool betweenDecl; /* WFC: PE Between Declarations */

+typedef enum XML_Error Processor(XML_Parser parser, const char *start,

+ const char *end, const char **endPtr);

+ bool betweenDecl, enum EntityType type);

+static void normalizePublicId(XML_Char *s);

+static void poolInit(STRING_POOL *pool, XML_Parser parser);

+static void poolClear(STRING_POOL *pool);

+static void poolDestroy(STRING_POOL *pool);

+static XML_Bool poolGrow(STRING_POOL *pool);

+static bool poolGrowUntil(STRING_POOL *pool, size_t needed);

+static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);

+static const XML_Char *poolCopyStringNoFinish(STRING_POOL *pool,

+ const XML_Char *s);

+static const XML_Char *poolAppendString(STRING_POOL *pool, const XML_Char *s);

+static int nextScaffoldPart(XML_Parser parser);

+ // Application callback invoked by callUnknownEncodingConvert.

+ int(XMLCALL *m_unknownEncodingConvert)(void *, const char *);

+static void

+callUnknownEncodingRelease(XML_Parser parser) {

+ beforeHandler(parser);

+ parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);

+ afterHandler(parser);

+ parser->m_unknownEncodingRelease = NULL;

+ parser->m_unknownEncodingData = NULL;

+}

+

+static int XMLCALL

+callUnknownEncodingConvert(void *data, const char *p) {

+ XML_Parser parser = data;

+ beforeHandler(parser);

+ const int result

+ = parser->m_unknownEncodingConvert(parser->m_unknownEncodingData, p);

+ afterHandler(parser);

+ return result;

+}

+

+ parser->m_unknownEncodingConvert = NULL;

+static void

+ callUnknownEncodingRelease(parser);

+static void

+ callUnknownEncodingRelease(parser);

+/* The body of XML_SetHashSalt, so that Expat's own tests can reach it

+ without tripping the deprecation of the public function. */

+XML_NONTESTING_STATIC int

+xmlSetHashSalt(XML_Parser parser, unsigned long hash_salt) {

+// DEPRECATED since Expat 2.8.0.

+int XMLCALL

+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {

+ return xmlSetHashSalt(parser, hash_salt);

+}

+

+ // NOTE: XML_Size is known to wrap around for >4 GiB content

+ // NOTE: XML_Size is known to wrap around for >4 GiB content

+static enum XML_Error

+static enum XML_Error

+static enum XML_Error

+static enum XML_Error

+static enum XML_Error

+ entity->open = true;

+ entity->open = false;

+ if (! elementType->defaultAttForName.parser)

+ hashTableInit(&(elementType->defaultAttForName), parser);

+ NAME_AND_DEFAULT_ATTRIBUTE *const nameAndDefaultAttribute

+ = (NAME_AND_DEFAULT_ATTRIBUTE *)lookup(

+ parser, &(elementType->defaultAttForName), attId->name, 0);

+ if (nameAndDefaultAttribute != NULL) {

+ assert(nameAndDefaultAttribute->attIndex < elementType->nDefaultAtts);

+ const DEFAULT_ATTRIBUTE *const att

+ = elementType->defaultAtts + nameAndDefaultAttribute->attIndex;

+ isCdata = att->isCdata;

+ if (parser->m_nsAttsPower == 0

+ || (nPrefixes >> (parser->m_nsAttsPower - 1))) {

+ FREE(parser, b);

+static enum XML_Error

+static enum XML_Error

+

+ parser->m_unknownEncodingRelease = info.release;

+ parser->m_unknownEncodingData = info.data;

+

+ if (parser->m_unknownEncodingRelease)

+ callUnknownEncodingRelease(parser);

+ else

+ parser->m_unknownEncodingData = NULL;

+ parser->m_unknownEncodingConvert = info.convert;

+ parser->m_unknownEncodingMem, info.map,

+ info.convert ? callUnknownEncodingConvert : NULL, parser);

+ parser->m_unknownEncodingConvert = NULL;

+ if (parser->m_unknownEncodingRelease != NULL)

+ callUnknownEncodingRelease(parser);

+ else

+ parser->m_unknownEncodingData = NULL;

+static enum XML_Error

+static enum XML_Error

+ parser->m_dtd->paramEntityRead = true;

+static enum XML_Error

+static enum XML_Error

+static enum XML_Error

+static enum XML_Error

+ dtd->paramEntityRead = false;

+ dtd->paramEntityRead = false;

+ parser->m_declEntity->is_param = false;

+ parser->m_declEntity->is_param = true;

+ bool betweenDecl = (role == XML_ROLE_PARAM_ENTITY_REF);

+ dtd->paramEntityRead = false;

+ entity->open = true;

+ entity->open = false;

+ entity->open = false;

+ dtd->in_eldecl = true;

+ dtd->in_eldecl = false;

+ dtd->in_eldecl = false;

+static enum XML_Error

+processEntity(XML_Parser parser, ENTITY *entity, bool betweenDecl,

+ entity->open = true;

+ entity->hasMore = true;

+static enum XML_Error

+ entity->hasMore = false;

+ entity->open = false;

+static enum XML_Error

+ entity->hasMore = false;

+ entity->open = false;

+ dtd->paramEntityRead = false;

+ entity->open = true;

+ entity->open = false;

+ entity->open = false;

+ entity->hasMore = false;

+ entity->open = false;

+static void

+ = lookup(parser, &(type->defaultAttForName), attId->name, 0);

+ attId->maybeTokenized = true;

+ NAME_AND_DEFAULT_ATTRIBUTE *const nameAndDefaultAttribute

+ = (NAME_AND_DEFAULT_ATTRIBUTE *)lookup(

+ parser, &(type->defaultAttForName), attId->name,

+ sizeof(NAME_AND_DEFAULT_ATTRIBUTE));

+ if (! nameAndDefaultAttribute)

+ assert(nameAndDefaultAttribute->name == attId->name);

+

+ // NOTE: The XML 1.0r4 spec says:

+ // "When more than one definition is provided for the same attribute of a

+ // given element type, the first declaration is binding and later

+ // declarations are ignored."

+ if (! nameAndDefaultAttribute->initialized) {

+ nameAndDefaultAttribute->attIndex = type->nDefaultAtts;

+ nameAndDefaultAttribute->initialized = true;

+ }

+

+ id->xmlns = true;

+ e->open = true;

+static void

+ p->paramEntityRead = false;

+ p->in_eldecl = false;

+ hashTableDestroy(&(e->defaultAttForName));

+ p->paramEntityRead = false;

+ p->in_eldecl = false;

+ hashTableDestroy(&(e->defaultAttForName));

+ if (! newE->defaultAttForName.parser)

+ hashTableInit(&(newE->defaultAttForName), parser);

+ NAME_AND_DEFAULT_ATTRIBUTE *const nameAndDefaultAttribute

+ = (NAME_AND_DEFAULT_ATTRIBUTE *)lookup(

+ parser, &(newE->defaultAttForName), attributeName,

+ sizeof(NAME_AND_DEFAULT_ATTRIBUTE));

+ if (! nameAndDefaultAttribute) {

+

+ // NOTE: The XML 1.0r4 spec says:

+ // "When more than one definition is provided for the same attribute of a

+ // given element type, the first declaration is binding and later

+ // declarations are ignored."

+ if (! nameAndDefaultAttribute->initialized) {

+ nameAndDefaultAttribute->attIndex = i;

+ nameAndDefaultAttribute->initialized = true;

+ }

+// Compares two strings `s1` and `s2` whereas:

+// - `s2` is zero-terminated but

+// - `s1` is made up of exactly (not just up to) `s1len` non-zero characters.

+XML_NONTESTING_STATIC XML_Bool

+keyeq(KEY s1, size_t s1len, KEY s2) {

+ return (wcsncmp(s1, s2, s1len) == 0 && s2[s1len] == L'\0') ? XML_TRUE

+ : XML_FALSE;

+ for (; s1len > 0 && *s1 == *s2; s1len--, s1++, s2++)

+ ; /* no loop body! */

+ return ((s1len == 0) && (*s2 == 0)) ? XML_TRUE : XML_FALSE;

+ return (strncmp(s1, s2, s1len) == 0 && s2[s1len] == '\0') ? XML_TRUE

+ : XML_FALSE;

+XML_NONTESTING_STATIC size_t

+static unsigned long

+hash(XML_Parser parser, KEY s, size_t keyLen) {

+ sip24_update(&state, s, keyLen * sizeof(XML_Char));

+// Function `lookupWithLength` can be used to either…

+//

+// a) check whether an element with key `name` exists in the given hash table

+// (read-only mode where `createSize == 0`) or

+//

+// b) check whether an element with key `name` exists in the given hash table

+// *and* insert it if missing (i.e. read-write mode where `createSize != 0`.

+//

+// When inserting, a block of `createSize` number of bytes will be allocated

+// and set to zero, and the resulting block of memory will be considered

+// to start with a `NAMED` structure, and `->name = name;` is performed.

+// The fact that all other bytes in the structure are initially zero can

+// be used to tell cases "existed and found" and "newly inserted" apart

+// with the structure returned.

+//

+// NOTE: Read-only lookup does not need zero-terminated keys but

+// read-write mode does, because keys can be re-hashed later and the

+// hash table does not store key length information.

+//

+XML_NONTESTING_STATIC NAMED *

+lookupWithLength(XML_Parser parser, HASH_TABLE *table, KEY name, size_t nameLen,

+ size_t createSize) {

+ i = hash(parser, name, nameLen) & ((unsigned long)table->size - 1);

+ unsigned long h = hash(parser, name, nameLen);

+ if (keyeq(name, nameLen, table->v[i]->name))

+ KEY const key = table->v[i]->name;

+ unsigned long newHash = hash(parser, key, keylen(key));

+ assert(createSize >= sizeof(NAMED));

+ table->v[i]->name = name; // NOTE: This requires and assumes zero termination!

+// Function `lookup` can be used to either…

+//

+// a) check whether an element with key `name` exists in the given hash table

+// (read-only mode where `createSize == 0`) or

+//

+// b) check whether an element with key `name` exists in the given hash table

+// *and* insert it if missing (i.e. read-write mode where `createSize != 0`.

+//

+// When inserting, a block of `createSize` number of bytes will be allocated

+// and set to zero, and the resulting block of memory will be considered

+// to start with a `NAMED` structure, and `->name = name;` is performed.

+// The fact that all other bytes in the structure are initially zero can

+// be used to tell cases "existed and found" and "newly inserted" apart

+// with the structure returned.

+//

+XML_NONTESTING_STATIC NAMED *

+lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {

+ return lookupWithLength(parser, table, name, keylen(name), createSize);

+}

+

+XML_NONTESTING_STATIC void

+XML_NONTESTING_STATIC void

+XML_NONTESTING_STATIC void

+XML_NONTESTING_STATIC void

+XML_NONTESTING_STATIC NAMED *

+static void

+static void

+static void

+static const XML_Char *

+static const XML_Char *

+static const XML_Char *

+static XML_Bool

+static bool

+static int

+ if (! ret->defaultAttForName.parser)

+ hashTableInit(&(ret->defaultAttForName), getRootParserOf(parser, NULL));

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+typedef int PROLOG_HANDLER(PROLOG_STATE *state, int tok, const char *ptr,

+ const char *end, const ENCODING *enc);

+static int common(PROLOG_STATE *state, int tok);

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+ Copyright (c) 2017-2026 Sebastian Pipping <sebastian@pipping.org>

+ int (*handler)(struct prolog_state *state, int tok, const char *ptr,

+ const char *end, const ENCODING *enc);

+ Copyright (c) 2026 Afonso Januário <afonso-januario@hotmail.com>

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+ int (*byteType)(const ENCODING *, const char *);

+ int (*isNameMin)(const ENCODING *, const char *);

+ int (*isNmstrtMin)(const ENCODING *, const char *);

+ int (*byteToAscii)(const ENCODING *, const char *);

+ int (*charMatches)(const ENCODING *, const char *, int);

+ int (*isName2)(const ENCODING *, const char *);

+ int (*isName3)(const ENCODING *, const char *);

+ int (*isName4)(const ENCODING *, const char *);

+ int (*isNmstrt2)(const ENCODING *, const char *);

+ int (*isNmstrt3)(const ENCODING *, const char *);

+ int (*isNmstrt4)(const ENCODING *, const char *);

+ int (*isInvalid2)(const ENCODING *, const char *);

+ int (*isInvalid3)(const ENCODING *, const char *);

+ int (*isInvalid4)(const ENCODING *, const char *);

+/* Like NULL_VTABLE but with a real isInvalid4 so the UTF-16 encodings reject a

+ high surrogate that is not followed by a low surrogate. Only needed for the

+ XML_MIN_SIZE build, where the shared tokenizer dispatches through the vtable;

+ the regular build inlines the same check via IS_INVALID_CHAR. */

+#ifdef XML_MIN_SIZE

+# define UTF16_NULL_VTABLE(E) \

+ /* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL, \

+ /* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL, \

+ /* isInvalid2 */ NULL, /* isInvalid3 */ NULL, E##isInvalid4

+#else

+# define UTF16_NULL_VTABLE(E) NULL_VTABLE

+#endif

+

+static int checkCharRefNumber(int result);

+static int

+static int

+static int

+static enum XML_Convert_Result

+static enum XML_Convert_Result

+static enum XML_Convert_Result

+static enum XML_Convert_Result

+static enum XML_Convert_Result

+static int

+ static enum XML_Convert_Result E##toUtf8( \

+ static enum XML_Convert_Result E##toUtf16( \

+/* A 4-byte UTF-16 character is a surrogate pair; byteType only reports BT_LEAD4

+ for a high surrogate, so the pair is invalid unless the second unit is a low

+ surrogate (U+DC00..U+DFFF, i.e. high byte 0xDC..0xDF). */

+#define LITTLE2_IS_INVALID_CHAR(p, n) \

+ ((n) == 4 && ((unsigned char)(p)[3] & 0xFC) != 0xDC)

+static int

+static int

+static int

+static int

+static int

+static int

+little2_isInvalid4(const ENCODING *enc, const char *p) {

+ UNUSED_P(enc);

+ return LITTLE2_IS_INVALID_CHAR(p, 4);

+}

+

+# define IS_INVALID_CHAR(enc, p, n) LITTLE2_IS_INVALID_CHAR(p, n)

+ STANDARD_VTABLE(little2_) UTF16_NULL_VTABLE(little2_)};

+ STANDARD_VTABLE(little2_) UTF16_NULL_VTABLE(little2_)};

+ STANDARD_VTABLE(little2_) UTF16_NULL_VTABLE(little2_)};

+ STANDARD_VTABLE(little2_) UTF16_NULL_VTABLE(little2_)};

+/* A 4-byte UTF-16 character is a surrogate pair; byteType only reports BT_LEAD4

+ for a high surrogate, so the pair is invalid unless the second unit is a low

+ surrogate (U+DC00..U+DFFF, i.e. high byte 0xDC..0xDF). */

+#define BIG2_IS_INVALID_CHAR(p, n) \

+ ((n) == 4 && ((unsigned char)(p)[2] & 0xFC) != 0xDC)

+static int

+static int

+static int

+static int

+static int

+static int

+big2_isInvalid4(const ENCODING *enc, const char *p) {

+ UNUSED_P(enc);

+ return BIG2_IS_INVALID_CHAR(p, 4);

+}

+

+# define IS_INVALID_CHAR(enc, p, n) BIG2_IS_INVALID_CHAR(p, n)

+ STANDARD_VTABLE(big2_) UTF16_NULL_VTABLE(big2_)};

+ STANDARD_VTABLE(big2_) UTF16_NULL_VTABLE(big2_)};

+ STANDARD_VTABLE(big2_) UTF16_NULL_VTABLE(big2_)};

+ STANDARD_VTABLE(big2_) UTF16_NULL_VTABLE(big2_)};

+static int

+static void

+static int

+static const char KW_1_dot[] = {ASCII_1, ASCII_PERIOD, '\0'};

+

+/* Checks a version pseudo-attribute value against the VersionNum production.

+ XML 1.0 Fourth Edition only allows the literal "1.0", but the Fifth

+ Edition relaxed this to "1." followed by one or more digits, since Expat

+ only implements 1.0 itself but plans to track the Fifth Edition's laxer

+ grammar here so that "1.1" and similar aren't rejected only to have that

+ rejection reverted later. Returns true for a value matching "1.[0-9]+".

+ val/valEnd bound the value itself; valEnd is the upper bound used when

+ decoding the individual characters between them. */

+static bool

+checkXmlDeclVersionNum(const ENCODING *enc, const char *val,

+ const char *valEnd) {

+ if (valEnd - val < 2 * enc->minBytesPerChar

+ || ! XmlNameMatchesAscii(enc, val, val + 2 * enc->minBytesPerChar,

+ KW_1_dot))

+ return false;

+ val += 2 * enc->minBytesPerChar;

+ if (val == valEnd)

+ return false;

+ for (; val != valEnd; val += enc->minBytesPerChar) {

+ int c = toAscii(enc, val, valEnd);

+ if (c < ASCII_0 || c > ASCII_9)

+ return false;

+ }

+ return true;

+}

+

+ /* Expat implements XML 1.0 only, so any version outside the "1.0"/"1.x"

+ family is rejected. Following the Fifth Edition's VersionNum

+ production (rather than the Fourth Edition's exact "1.0") avoids

+ rejecting "1.1" now only to have to revert that once Expat tracks

+ the newer edition. */

+ if (! checkXmlDeclVersionNum(enc, val, ptr - enc->minBytesPerChar)) {

+ *badPtr = val;

+ return 0;

+ }

+static int

+int

+int

+static int

+static int

+static int

+static enum XML_Convert_Result

+static enum XML_Convert_Result

+static int

+typedef int (*SCANNER)(const ENCODING *, const char *, const char *,

+ const char **);

+ XML_CONVERT_OUTPUT_EXHAUSTED = 2 /* and therefore potentially input remaining

+ as well */

+ int (*nameMatchesAscii)(const ENCODING *, const char *, const char *,

+ const char *);

+ int (*nameLength)(const ENCODING *, const char *);

+ const char *(*skipS)(const ENCODING *, const char *);

+ int (*getAtts)(const ENCODING *enc, const char *ptr, int attsMax,

+ ATTRIBUTE *atts);

+ int (*charRefNumber)(const ENCODING *enc, const char *ptr);

+ int (*predefinedEntityName)(const ENCODING *, const char *, const char *);

+ void (*updatePosition)(const ENCODING *, const char *ptr, const char *end,

+ POSITION *);

+ int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end,

+ const char **badPtr);

+ enum XML_Convert_Result (*utf8Convert)(const ENCODING *enc,

+ const char **fromP,

+ const char *fromLim, char **toP,

+ const char *toLim);

+ enum XML_Convert_Result (*utf16Convert)(const ENCODING *enc,

+ const char **fromP,

+ const char *fromLim,

+ unsigned short **toP,

+ const unsigned short *toLim);

+int XmlUtf8Encode(int charNumber, char *buf);

+int XmlUtf16Encode(int charNumber, unsigned short *buf);

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+ Copyright (c) 2026 Kartik Kenchi <netliomax25@gmail.com>

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static int

+static const char *

+static void

+ Copyright (c) 2017-2026 Sebastian Pipping <sebastian@pipping.org>

+static int

+static int

+ hash_tests.c \

+ hash_tests.h \

+ memcheck.h \

+ minicheck.h \

+ structdata.h \

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+ dummy.$(OBJEXT) handlers.$(OBJEXT) hash_tests.$(OBJEXT) \

+ memcheck.$(OBJEXT) minicheck.$(OBJEXT) misc_tests.$(OBJEXT) \

+ ns_tests.$(OBJEXT) nsalloc_tests.$(OBJEXT) runtests.$(OBJEXT) \

+ ./$(DEPDIR)/hash_tests.Po ./$(DEPDIR)/memcheck.Po \

+ ./$(DEPDIR)/minicheck.Po ./$(DEPDIR)/misc_tests.Po \

+ ./$(DEPDIR)/ns_tests.Po ./$(DEPDIR)/nsalloc_tests.Po \

+ ./$(DEPDIR)/runtests.Po ./$(DEPDIR)/structdata.Po

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ hash_tests.c \

+ hash_tests.h \

+ memcheck.h \

+ minicheck.h \

+ structdata.h \

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign tests/Makefile'; \

+ $(AUTOMAKE) --foreign tests/Makefile

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hash_tests.Po@am__quote@ # am--include-marker

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ -rm -f ./$(DEPDIR)/hash_tests.Po

+ -rm -f ./$(DEPDIR)/hash_tests.Po

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_ACC_TESTS_H

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_ALLOC_TESTS_H

+ Copyright (c) 2026 Zeyou Liu <zeyouliu@tencent.com>

+ Copyright (c) 2026 Afonso Januário <afonso-januario@hotmail.com>

+ Copyright (c) 2026 Braian Plaku <braianplaku@gmail.com>

+ xmlSetHashSalt(g_parser, COLLIDING_HASH_SALT);

+/* Regression test for GH #967: Expat only implements XML 1.0 Fourth

+ Edition, so a declared version outside the "1.x" family must be

+ rejected rather than silently accepted. A version matching the Fifth

+ Edition's VersionNum production ("1." followed by one or more digits)

+ is accepted even though Expat itself only implements 1.0 Fourth

+ Edition, per GH #967's review thread: rejecting "1.1" now would just

+ have to be reverted once Expat tracks the Fifth Edition, so it's let

+ through rather than blocked twice. */

+START_TEST(test_xmldecl_wrong_version_number) {

+ const char *const badVersions[] = {"2.3", "0.9", "10", "1.", "1", " 1.0 "};

+

+ for (size_t i = 0; i < sizeof(badVersions) / sizeof(badVersions[0]); i++) {

+ char doc[64];

+ snprintf(doc, sizeof(doc), "<?xml version='%s'?>\n<doc/>", badVersions[i]);

+ set_subtest("version='%s'", badVersions[i]);

+

+ XML_Parser parser = XML_ParserCreate(NULL);

+ assert_true(_XML_Parse_SINGLE_BYTES(parser, doc, (int)strlen(doc), XML_TRUE)

+ == XML_STATUS_ERROR);

+ assert_true(XML_GetErrorCode(parser) == XML_ERROR_XML_DECL);

+ XML_ParserFree(parser);

+ }

+}

+END_TEST

+

+/* GH #967's review pointed out that XML 1.0 Fifth Edition relaxed

+ VersionNum to "1." followed by one or more digits, so versions like

+ "1.1" and "1.123" should parse rather than being rejected. */

+START_TEST(test_xmldecl_accepts_1_x_version) {

+ const char *const goodVersions[] = {"1.1", "1.123"};

+

+ for (size_t i = 0; i < sizeof(goodVersions) / sizeof(goodVersions[0]); i++) {

+ char doc[64];

+ snprintf(doc, sizeof(doc), "<?xml version='%s'?>\n<doc/>", goodVersions[i]);

+ set_subtest("version='%s'", goodVersions[i]);

+

+ XML_Parser parser = XML_ParserCreate(NULL);

+ assert_true(_XML_Parse_SINGLE_BYTES(parser, doc, (int)strlen(doc), XML_TRUE)

+ == XML_STATUS_OK);

+ XML_ParserFree(parser);

+ }

+}

+END_TEST

+

+// Helper that creates a UTF-16LE copy of UTF-16BE literal input and vice versa

+static char *

+utf16_dup_flipped(const char *text, size_t lenBytes) {

+ assert_true(lenBytes < SIZE_MAX);

+ assert_true(lenBytes % 2 == 0);

+ char *const buffer = malloc(lenBytes + 1);

+ assert_true(buffer != NULL);

+

+ for (size_t i = 0; i < lenBytes; i++) {

+ // This maps 0 -> 1, 1 -> 0, 2 -> 3, 3 -> 2, 4 -> 5, ..

+ size_t j = i + ((i % 2 == 0) ? +1 : -1);

+ assert_true(j < lenBytes);

+ buffer[j] = text[i];

+ }

+

+ buffer[lenBytes] = '\0';

+

+ return buffer;

+}

+

+/* Tests that invalid combinations of surrogates are detected when decoding

+ UTF-16, both little-endian and big-endian.

+ Previously, a high surrogate not followed by a low surrogate slipped

+ through. Without validation the high would consume the next

+ code unit as a fake low, hiding e.g. a following '<' from the

+ tokenizer. */

+START_TEST(test_utf16_surrogate_pairs) {

+ struct TestCase {

+ const char *idea;

+ const char *content;

+ bool expectedSuccess;

+ };

+

+ struct TestCase testCases[] = {

+ // Group {smallest high - 1}{*}

+ {"{smallest high - 1}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ true},

+ {"{smallest high - 1}{smallest high}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high - 1}{largest high}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high - 1}{smallest low}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high - 1}{largest low}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high - 1}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xD7\xFF"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ true},

+ // Group {smallest high}{*}

+ {"{smallest high}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high}{smallest high}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high}{largest high}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest high}{smallest low}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ true},

+ {"{smallest high}{largest low}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ true},

+ {"{smallest high}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xD8\x00"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ false},

+ // Group {largest high}{*}

+ {"{largest high}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest high}{smallest high}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest high}{largest high}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest high}{smallest low}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ true},

+ {"{largest high}{largest low}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ true},

+ {"{largest high}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xDB\xFF"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ false},

+ // Group {smallest low}{*}

+ {"{smallest low}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest low}{smallest high}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest low}{largest high}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest low}{smallest low}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest low}{largest low}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{smallest low}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xDC\x00"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ false},

+ // Group {largest low}{*}

+ {"{largest low}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low}{smallest high}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low}{largest high}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low}{smallest low}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low}{largest low}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xDF\xFF"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ false},

+ // Group {largest low + 1}{*}

+ {"{largest low + 1}{smallest high - 1}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xD7\xFF"

+ "\0<\0/\0a\0>",

+ true},

+ {"{largest low + 1}{smallest high}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xD8\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low + 1}{largest high}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xDB\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low + 1}{smallest low}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xDC\x00"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low + 1}{largest low}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xDF\xFF"

+ "\0<\0/\0a\0>",

+ false},

+ {"{largest low + 1}{largest low + 1}",

+ "\0<\0a\0>"

+ "\xE0\x00"

+ "\xE0\x00"

+ "\0<\0/\0a\0>",

+ true},

+ };

+

+ for (size_t i = 0; i < sizeof(testCases) / sizeof(testCases[0]); i++) {

+ set_subtest("%s", testCases[i].idea);

+

+ const int lenBytes = /*<a>*/ 6 + /*first*/ 2 + /*second*/ 2 + /*</a>*/ 8;

+ const bool expectedSuccess = testCases[i].expectedSuccess;

+ const enum XML_Status expectedStatus

+ = (expectedSuccess ? XML_STATUS_OK : XML_STATUS_ERROR);

+

+ const char *const bigEndian = testCases[i].content;

+ char *const littleEndian = utf16_dup_flipped(bigEndian, lenBytes);

+ assert_true(littleEndian != NULL);

+ const char *endianCases[] = {bigEndian, littleEndian};

+

+ for (size_t j = 0; j < sizeof(endianCases) / sizeof(endianCases[0]); j++) {

+ const char *text = endianCases[j];

+

+ assert_true(text[lenBytes] == '\0'); // self-test

+ assert_true((text[0] == '\0')

+ != (text[lenBytes - 1] == '\0')); // self-test

+

+ XML_Parser parser = XML_ParserCreate(NULL);

+ assert_true(parser != NULL);

+

+ assert_true(_XML_Parse_SINGLE_BYTES(parser, text, lenBytes, XML_TRUE)

+ == expectedStatus);

+ if (! expectedSuccess) {

+ assert_true(XML_GetErrorCode(parser) == XML_ERROR_INVALID_TOKEN);

+ }

+

+ XML_ParserFree(parser);

+ }

+

+ free(littleEndian);

+ }

+}

+END_TEST

+

+ xmlSetHashSalt(g_parser, 0x12345678);

+ if (xmlSetHashSalt(g_parser, 0x23456789))

+ xmlSetHashSalt(g_parser, 0x12345678);

+ if (xmlSetHashSalt(g_parser, 0x23456789))

+static void XMLCALL

+check_second_attr_normalization(void *userData, const XML_Char *name,

+ const XML_Char **atts) {

+ int *const seen_second = userData;

+ UNUSED_P(name);

+

+ for (size_t i = 0; atts[i] != NULL; i += 2) {

+ const XML_Char *const key = atts[i];

+ const XML_Char *const value = atts[i + 1];

+ if (xcstrcmp(key, XCS("second")) != 0)

+ continue;

+ *seen_second = 1;

+ /* Attribute "second" is not of type CDATA, so leading, trailing and

+ * repeated whitespace is to be normalized away. */

+ if (xcstrcmp(value, XCS("a b")) != 0)

+ fail("Attribute of non-CDATA type was not whitespace-normalized");

+ }

+}

+

+static int XMLCALL

+external_entity_attr_checker(XML_Parser parser, const XML_Char *context,

+ const XML_Char *base, const XML_Char *systemId,

+ const XML_Char *publicId) {

+ const char *const text = "<tag second=' a b '/>";

+ UNUSED_P(base);

+ UNUSED_P(systemId);

+ UNUSED_P(publicId);

+

+ XML_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_OK)

+ xml_failure(ext_parser);

+

+ XML_ParserFree(ext_parser);

+ return XML_STATUS_OK;

+}

+

+START_TEST(test_default_attr_index_after_dtd_copy) {

+ /* Function storeAtts resolves member .attIndex of structure

+ * NAME_AND_DEFAULT_ATTRIBUTE to tell whether an attribute value needs

+ * whitespace normalization, so function dtdCopy needs to carry that index

+ * over to the copy. Attribute "first" is declared before attribute

+ * "second" so that a mixed-up index resolves to the wrong declaration.

+ */

+ const char *text = "<!DOCTYPE doc [\n"

+ " <!ENTITY e SYSTEM 'entity.ent'>\n"

+ " <!ELEMENT doc ANY>\n"

+ " <!ELEMENT tag EMPTY>\n"

+ " <!ATTLIST tag first CDATA #IMPLIED>\n"

+ " <!ATTLIST tag second NMTOKENS #IMPLIED>\n"

+ "]>\n"

+ "<doc>&e;</doc>\n";

+ int seen_second = 0;

+

+ XML_Parser parser = XML_ParserCreate(NULL);

+ assert_true(parser != NULL);

+ XML_SetUserData(parser, &seen_second);

+ XML_SetExternalEntityRefHandler(parser, external_entity_attr_checker);

+ XML_SetStartElementHandler(parser, check_second_attr_normalization);

+

+ if (_XML_Parse_SINGLE_BYTES(parser, text, (int)strlen(text), XML_TRUE)

+ != XML_STATUS_OK)

+ xml_failure(parser);

+ if (! seen_second)

+ fail("Attribute \"second\" has not been reported");

+

+ XML_ParserFree(parser);

+}

+END_TEST

+

+#else

+ UNUSED_P(maxbuf);

+#else

+ UNUSED_P(maxbuf);

+ tcase_add_test(tc_basic, test_xmldecl_wrong_version_number);

+ tcase_add_test(tc_basic, test_xmldecl_accepts_1_x_version);

+ tcase_add_test(tc_basic, test_utf16_surrogate_pairs);

+ tcase_add_test__if_xml_ge(tc_basic, test_default_attr_index_after_dtd_copy);

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_BASIC_TESTS_H

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign tests/benchmark/Makefile'; \

+ $(AUTOMAKE) --foreign tests/benchmark/Makefile

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ Copyright (c) 2017-2026 Sebastian Pipping <sebastian@pipping.org>

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_COMMON_H

+#include "expat_config.h"

+#include "minicheck.h"

+#include "chardata.h"

+#ifdef XML_LARGE_SIZE

+# define XML_FMT_INT_MOD "ll"

+#else

+# define XML_FMT_INT_MOD "l"

+#endif

+#ifdef XML_UNICODE_WCHAR_T

+# 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"

+# 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 */

+#define xml_failure(parser) _xml_failure((parser), __FILE__, __LINE__)

+#define expect_failure(text, errorCode, errorMessage) \

+ _expect_failure((text), (errorCode), (errorMessage), __FILE__, __LINE__)

+#define run_character_check(text, expected) \

+ _run_character_check(text, expected, __FILE__, __LINE__)

+#define run_attribute_check(text, expected) \

+ _run_attribute_check(text, expected, __FILE__, __LINE__)

+#define run_ext_character_check(text, test_data, expected) \

+ _run_ext_character_check(text, test_data, expected, __FILE__, __LINE__)

+#define ALLOC_ALWAYS_SUCCEED (-1)

+#define REALLOC_ALWAYS_SUCCEED (-1)

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_DUMMY_H

+#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 XML_HANDLERS_H

+#include "expat_config.h"

+#include "expat.h"

+#define STRUCT_START_TAG 0

+#define STRUCT_END_TAG 1

+#define handler_record_get(storage, index) \

+ _handler_record_get((storage), (index), __FILE__, __LINE__)

+#define assert_record_handler_called(storage, index, expected_name, \

+ expected_arg) \

+ do { \

+ const struct handler_record_entry *e = handler_record_get(storage, index); \

+ assert_true(strcmp(e->name, expected_name) == 0); \

+ assert_true(e->arg == (expected_arg)); \

+ } while (0)

+#define ENTITY_MATCH_FAIL (-1)

+#define ENTITY_MATCH_NOT_FOUND (0)

+#define ENTITY_MATCH_SUCCESS (1)

+/* Tests related to the hash tables used inside Expat

+__ __ _

+ ___\ \/ /_ __ __ _| |_

+ / _ \\ /| '_ \ / _` | __|

+ | __// \| |_) | (_| | |_

+ \___/_/\_\ .__/ \__,_|\__|

+ |_| XML parser

+

+ Copyright (c) 2026 Sebastian Pipping <sebastian@pipping.org>

+ 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.

+

+ SPDX-License-Identifier: MIT

+*/

+

+#include "hash_tests.h"

+

+#include "common.h" // for XCS

+#include "expat.h"

+#include "hash_table.h"

+#include "minicheck.h"

+

+#include <stdbool.h>

+#include <string.h> // for memcmp

+

+START_TEST(test_hash_table) {

+ // The test is not doing any parsing, so a single run

+ // (with `g_chunkSize == 0`) is enough

+ if (g_chunkSize != 0)

+ return;

+

+ typedef struct {

+ const XML_Char *name;

+ bool initialized;

+ } NAME_AND_FLAG;

+

+ HASH_TABLE table;

+ XML_Parser parser = XML_ParserCreate(NULL);

+ hashTableInit(&table, parser);

+

+ const XML_Char *const key1 = XCS("key1");

+ const XML_Char *const key2 = XCS("key2");

+ const XML_Char *const key3 = XCS("key1overlap");

+

+ // Self-test: `key3` starts with `key1` but is different from it

+ assert_true(memcmp(key1, key3, keylen(key1)) == 0);

+ assert_true(keyeq(key1, keylen(key1), key3) == XML_FALSE);

+

+ // Test: Look up false for all keys because the table is empty

+ assert_true(lookup(parser, &table, key1, 0) == NULL);

+ assert_true(lookup(parser, &table, key2, 0) == NULL);

+ assert_true(lookup(parser, &table, key3, 0) == NULL);

+

+ // Test: Iteration yields 0 items initially

+ {

+ HASH_TABLE_ITER iter1;

+ hashTableIterInit(&iter1, &table);

+ assert_true(hashTableIterNext(&iter1) == NULL);

+ }

+

+ // Test: Insertion works (including initialization to zero)

+ NAME_AND_FLAG *const inserted1

+ = (NAME_AND_FLAG *)lookup(parser, &table, key1, sizeof(NAME_AND_FLAG));

+ assert_true(inserted1 != NULL);

+ assert_true(inserted1->name == key1);

+ assert_true(! inserted1->initialized);

+

+ // Make it possible to tell the struct apart from a freshly inserted version

+ inserted1->initialized = true;

+

+ // Test: Only present keys can be looked up

+ assert_true(lookup(parser, &table, key1, 0) != NULL);

+ assert_true(lookup(parser, &table, key2, 0) == NULL);

+ assert_true(lookup(parser, &table, key3, 0) == NULL);

+

+ // Test: Key length works without false positives

+ assert_true(lookupWithLength(parser, &table, key3, /*nameLen=*/3, 0) == NULL);

+ assert_true(lookupWithLength(parser, &table, key3, /*nameLen=*/4, 0) != NULL);

+ assert_true(lookupWithLength(parser, &table, key3, /*nameLen=*/5, 0) == NULL);

+

+ // TEST: Lookup does not reset existing entries to zeros

+ NAME_AND_FLAG *const found

+ = (NAME_AND_FLAG *)lookup(parser, &table, key1, sizeof(NAME_AND_FLAG));

+ assert_true(found != NULL);

+ assert_true(found->name == key1);

+ assert_true(found->initialized); // this is key

+

+ // Test: Insertion of a second item works

+ assert_true(lookup(parser, &table, key2, 0) == NULL);

+ assert_true(lookup(parser, &table, key2, sizeof(NAME_AND_FLAG)) != NULL);

+ assert_true(lookup(parser, &table, key2, 0) != NULL);

+

+ // Test: Iteration yields nothing but the two expected items

+ {

+ HASH_TABLE_ITER iter2;

+ hashTableIterInit(&iter2, &table);

+ size_t itemCount = 0;

+ while (true) {

+ const NAME_AND_FLAG *const item

+ = (const NAME_AND_FLAG *)hashTableIterNext(&iter2);

+ if (item == NULL)

+ break;

+

+ itemCount++;

+

+ if (keyeq(key1, keylen(key1), item->name) == XML_TRUE)

+ assert_true(item->initialized);

+ else if (keyeq(key2, keylen(key2), item->name) == XML_TRUE)

+ assert_true(! item->initialized);

+ else

+ fail("unexpected item .name");

+ }

+ assert_true(itemCount == 2);

+ }

+

+ // Test: After clearing all lookups fail

+ hashTableClear(&table);

+ assert_true(lookup(parser, &table, key1, 0) == NULL);

+ assert_true(lookup(parser, &table, key2, 0) == NULL);

+ assert_true(lookup(parser, &table, key3, 0) == NULL);

+

+ // Test: After clearing iteration yields 0 items again

+ {

+ HASH_TABLE_ITER iter3;

+ hashTableIterInit(&iter3, &table);

+ assert_true(hashTableIterNext(&iter3) == NULL);

+ }

+

+ hashTableDestroy(&table);

+ XML_ParserFree(parser);

+}

+END_TEST

+

+void

+make_hash_test_case(Suite *s) {

+ TCase *const tc_hash = tcase_create("hash tests");

+ suite_add_tcase(s, tc_hash);

+ tcase_add_test(tc_hash, test_hash_table);

+}

+/* Tests related to the hash tables used inside Expat

+ __ __ _

+ ___\ \/ /_ __ __ _| |_

+ / _ \\ /| '_ \ / _` | __|

+ | __// \| |_) | (_| | |_

+ \___/_/\_\ .__/ \__,_|\__|

+ |_| XML parser

+

+ Copyright (c) 2026 Sebastian Pipping <sebastian@pipping.org>

+ 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.

+

+ SPDX-License-Identifier: MIT

+*/

+

+#ifndef XML_HASH_TESTS_H

+#define XML_HASH_TESTS_H

+

+#include "minicheck.h"

+

+extern void make_hash_test_case(Suite *s);

+

+#endif /* XML_HASH_TESTS_H */

+ Copyright (c) 2026 Leo Camus <leo.camus23@gmail.com>

+ alloc_tail = entry->prev;

+ Copyright (c) 2017 Rhodri James <rhodri@wildebeest.org.uk>

+ Copyright (c) 2017-2026 Sebastian Pipping <sebastian@pipping.org>

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_MINICHECK_H

+#define CK_NOFORK 0

+#define CK_FORK 1

+#define CK_SILENT 0

+#define CK_NORMAL 1

+#define CK_VERBOSE 2

+#if defined(__GNUC__)

+# define PRINTF_LIKE(fmtpos, argspos) \

+ __attribute__((format(printf, fmtpos, argspos)))

+#else

+# define PRINTF_LIKE(fmtpos, argspos)

+#endif

+#define START_TEST(testname) \

+ static void testname(void) { \

+ _check_set_test_info(__func__, __FILE__, __LINE__); \

+ {

+#define END_TEST \

+ } \

+ }

+#define fail(msg) _fail(__FILE__, __LINE__, msg)

+#define assert_true(cond) \

+ do { \

+ if (! (cond)) { \

+ _fail(__FILE__, __LINE__, "check failed: " #cond); \

+ } \

+ } while (0)

+#if defined(__has_attribute)

+# if __has_attribute(noreturn)

+#endif

+ Copyright (c) 2026 Darren Carreras <carrerasdarren@gmail.com>

+ if (xcstrcmp(version_text, XCS("expat_2.8.5"))

+typedef struct {

+ XML_Parser parser;

+ int converterCallCount;

+ int releaseCallCount;

+} EncodingCallbackData;

+

+static int XMLCALL

+reentrant_encoding_converter(void *userData, const char *s) {

+ EncodingCallbackData *const data = userData;

+ UNUSED_P(s);

+ data->converterCallCount++;

+ forbidden_calls_character_handler(data->parser, NULL, 0);

+ return 'A';

+}

+

+static void XMLCALL

+reentrant_encoding_release(void *userData) {

+ EncodingCallbackData *const data = userData;

+ data->releaseCallCount++;

+ forbidden_calls_character_handler(data->parser, NULL, 0);

+}

+

+static int XMLCALL

+reentrant_encoding_handler(void *userData, const XML_Char *name,

+ XML_Encoding *info) {

+ EncodingCallbackData *const data = userData;

+ UNUSED_P(name);

+

+ for (int i = 0; i < 256; i++)

+ info->map[i] = i;

+ info->map[0x80] = -2; // Route byte 0x80 through the custom converter.

+ info->data = data;

+ info->convert = reentrant_encoding_converter;

+ info->release = reentrant_encoding_release;

+ return XML_STATUS_OK;

+}

+

+START_TEST(test_misc_unknown_encoding_callbacks_protected) {

+ const char *const doc

+ = "<?xml version='1.0' encoding='reentrant-conv'?><doc>\x80\x80</doc>";

+ XML_Parser parser = XML_ParserCreate(NULL);

+ EncodingCallbackData data = {parser, 0, 0};

+ XML_SetUnknownEncodingHandler(parser, reentrant_encoding_handler, &data);

+

+ assert_true(XML_Parse(parser, doc, (int)strlen(doc), /*isFinal=*/XML_TRUE)

+ == XML_STATUS_OK);

+ assert_true(data.converterCallCount > 0);

+ assert_true(data.releaseCallCount == 0); // Released by XML_ParserFree below.

+

+ XML_ParserFree(parser);

+ assert_true(data.releaseCallCount == 1);

+}

+END_TEST

+

+ tcase_add_test(tc_misc, test_misc_unknown_encoding_callbacks_protected);

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_MISC_TESTS_H

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_NS_TESTS_H

+#include "expat_config.h"

+

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#define XML_NSALLOC_TESTS_H

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#include "hash_tests.h"

+ make_hash_test_case(s);

+ Copyright (c) 2026 Sebastian Pipping <sebastian@pipping.org>

+# Copyright (c) 2026 Huang Wenbin <huangwenbin@kylinos.cn>

+test "$ERROR" -eq 0

+# Makefile.in generated by automake 1.19 from Makefile.am.

+# Copyright (C) 1994-2026 Free Software Foundation, Inc.

+am__tar_ignore_stderr = @am__tar_ignore_stderr@

+ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign xmlwf/Makefile'; \

+ $(AUTOMAKE) --foreign xmlwf/Makefile

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\

+@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Po

+@am__fastdepCC_TRUE@ $(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\

+@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\

+@am__fastdepCC_TRUE@ $(am__mv) $$depbase.Tpo $$depbase.Plo

+ am__distdir="$(distdir)"; \

+ sed "/\//!d;s|^|$$am__distdir/|;s,/[^/]*$$,," | \

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#include "expat_config.h" // for off_t

+

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+bool

+ return (bool)result;

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+#include <stdbool.h>

+

+extern bool XML_ProcessFile(XML_Parser parser, const XML_Char *filename,

+ unsigned flags);

+ Copyright (c) 2016-2026 Sebastian Pipping <sebastian@pipping.org>

+ T(" -k when processing multiple files, [k]eep processing after first file with error, and make the last error determine the exit code.\n")

+ T(" 3 one or more output files could not be written\n")

+ const bool processingSuccess

+ = XML_ProcessFile(parser, useStdin ? NULL : argv[i], processFlags);

+ bool closingSuccess = true;

+ closingSuccess = (fclose(userData.fp) == 0);

+ if (! closingSuccess)

+ tperror(outName);

+ if (! processingSuccess || ! closingSuccess) {

+ if (! processingSuccess || ! closingSuccess) {

+ // NOTE: If both failed, the last error should determine the exit code.

+ // Failure to close happened after failure to process.

+ if (! closingSuccess)

+ exitCode = XMLWF_EXIT_OUTPUT_ERROR;

+ else if (! processingSuccess)

+ exitCode = XMLWF_EXIT_NOT_WELLFORMED;

+

+ 3 one or more output files could not be written

+ help=(

+ "when processing multiple files, [k]eep processing after first file with error"

+ ", and make the last error determine the exit code."

+ ),

+# Copyright (c) 2019-2026 Sebastian Pipping <sebastian@pipping.org>

+set -e

+

+cd "$(dirname "$(type -P "$0")")"

+

+./xmlwf_helpgen.py | sed \