{"messages": [{"content": "You are a security engineer fixing a CVE. You are given the vulnerability description (symptom only) and the vulnerable source window. Author the MINIMAL fix as a unified diff. Follow these rules exactly:\n1. Target ONLY the file named in the `# Vulnerable source (...)` header \u2014 do not invent or substitute file paths.\n2. Modify ONLY code visible in the shown source window.\n3. Change as few lines as possible; do not rewrite surrounding logic.\n4. Output only the unified diff with no other text.\n5. Prefer the minimal structural change: if an existing condition is missing a check, add it inline to that condition rather than inserting a new code block. If existing code is redundant or overcomplicated, replace it \u2014 do not add more code around it.\n6. Edit the most specific method or class that directly handles the vulnerable operation \u2014 not a base class, interface, or Protocol definition.", "role": "system"}, {"content": "# CVE\nCVE-2019-5544: openslp parses attacker-controlled SLP network messages and uses a shared opaque buffer descriptor ring; the copy path for incoming option strings does not verify enough space remains before the end pointer, so a crafted peer message can overflow the heap allocation and write arbitrary data into adjacent memory.\n\n# Vulnerable source (common/slp_buffer.c)\n```c\n/*-------------------------------------------------------------------------\n * Copyright (C) 2000 Caldera Systems, Inc\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n *\n *    Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n *\n *    Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *\n *    Neither the name of Caldera Systems nor the names of its\n *    contributors may be used to endorse or promote products derived\n *    from this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n * `AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE CALDERA\n * SYSTEMS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,\n * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON\n * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *-------------------------------------------------------------------------*/\n\n/** Functions for managing SLP message buffers.\n *\n * This file provides a higher level abstraction over malloc and free that\n * deals specifically with message buffer management.\n *\n * @file       slp_buffer.c\n * @author     Matthew Peterson, John Calcote (jcalcote@novell.com)\n * @attention  Please submit patches to http://www.openslp.org\n * @ingroup    CommonCodeBuffers\n */\n\n#include \"slp_buffer.h\" \n#include \"slp_xmalloc.h\"\n\n/** Allocates an SLP message buffer.\n *\n * This routines must be called to initially allocate a SLPBuffer.\n *\n * @param[in] size The size of the buffer to be allocated.\n *\n * @return A newly allocated SLPBuffer, or NULL on memory allocation\n *    failure.\n *\n * @remarks An extra byte is allocated to store the terminating null for\n *    strings stored in the buffer. This extra byte is not counted in the \n *    buffer size.\n */\nSLPBuffer SLPBufferAlloc(size_t size)\n{\n   SLPBuffer result;\n\n   /* Allocate one extra byte for null terminating strings that \n    * occupy the last field of the buffer.\n    */\n   result = xmalloc(sizeof(struct _SLPBuffer) + size + 1);\n   if (result)\n   {\n      result->allocated = size;\n      result->start = (uint8_t *) (result + 1);\n      result->curpos = result->start;\n      result->end = result->start + size;\n\n#ifdef DEBUG\n      memset(result->start, 0x4d, size + 1);\n#endif\n   } \n   return result;\n}\n\n/** Resizes an SLP message buffer.\n *\n * This routine should be called to resize an existing memory buffer\n * that is too small.\n *\n * @param[in] buf    The buffer to be resized.\n * @param[in] size   The new size to reallocate for @p buf.\n *\n * @return A pointer to the newly allocated, or resized buffer is \n *    returned, or NULL on memory allocation failure.\n *\n * @sa See the @b remarks section for SLPBufferAlloc.\n */\nSLPBuffer SLPBufferRealloc(SLPBuffer buf, size_t size)\n{\n   SLPBuffer result;\n   if (buf)\n   {\n      if (buf->allocated >= size)\n         result = buf;\n      else\n      {\n         /* Allocate one extra byte for null terminating strings that \n          * occupy the last field of the buffer.\n          */\n         result = xrealloc(buf, sizeof(struct _SLPBuffer) + size + 1);\n         if (result)\n             result->allocated = size;\n      }\n      if (result)\n      {\n         result->start = (uint8_t *)(result + 1);\n         result->curpos = result->start;\n         result->end = result->start + size;\n\n#ifdef DEBUG\n         memset(result->start, 0x4d, size + 1);\n#endif \n      }\n   }\n   else\n      result = SLPBufferAlloc(size);\n   return result;\n}\n\n/** Returns a duplicate buffer.  \n *\n * Duplicate buffers must be freed by a call to SLPBufferFree.\n *\n * @param[in] buf The @c SLPBuffer to be duplicated.\n *\n * @return A newly allocated SLPBuffer that is a byte-for-byte copy\n *    of @p buf, or NULL on memory allocation failure.\n */\nSLPBuffer SLPBufferDup(SLPBuffer buf)\n{\n   SLPBuffer dup = 0;\n   if (buf && (dup = SLPBufferAlloc(buf->end - buf->start)) != 0)\n      memcpy(dup->start, buf->start, buf->end - buf->start + 1);\n   return dup;\n}\n\n/** Free an SLPBuffer.\n *\n * This routine releases the memory for a previously allocated \n * @c SLPBuffer object.\n *\n * @param[in] buf The SLPBuffer to be freed.\n */\nvoid SLPBufferFree(SLPBuffer buf)\n{\n   xfree(buf);\n}\n\n/*=========================================================================*/\n```", "role": "user"}, {"content": "diff --git a/common/slp_buffer.c b/common/slp_buffer.c\n--- a/common/slp_buffer.c\n+++ b/common/slp_buffer.c\n@@ -30,6 +30,13 @@\n  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n  *-------------------------------------------------------------------------*/\n \n+/* Copyright (c) 2019 VMware, Inc.\n+ * SPDX-License-Identifier: BSD-3-Clause\n+ * This file is provided under the BSD-3-Clause license.\n+ * See COPYING file for more details and other copyrights\n+ * that may apply.\n+ */\n+\n /** Functions for managing SLP message buffers.\n  *\n  * This file provides a higher level abstraction over malloc and free that\n@@ -153,4 +160,20 @@\n    xfree(buf);\n }\n \n+/** Report remaining free buffer size in bytes.\n+ *\n+ * Check if buffer is allocated and if so return bytes left in a\n+ * @c SLPBuffer object.\n+ *\n+ * @param[in] buf The SLPBuffer to be freed.\n+ */\n+size_t\n+RemainingBufferSpace(SLPBuffer buf)\n+{\n+   if (buf->allocated == 0) {\n+      return 0;\n+   }\n+   return buf->end - buf->curpos;\n+}\n+\n /*=========================================================================*/", "role": "assistant"}]}
{"messages": [{"content": "You are a security engineer fixing a CVE. You are given the vulnerability description (symptom only) and the vulnerable source window. Author the MINIMAL fix as a unified diff. Follow these rules exactly:\n1. Target ONLY the file named in the `# Vulnerable source (...)` header \u2014 do not invent or substitute file paths.\n2. Modify ONLY code visible in the shown source window.\n3. Change as few lines as possible; do not rewrite surrounding logic.\n4. Output only the unified diff with no other text.\n5. Prefer the minimal structural change: if an existing condition is missing a check, add it inline to that condition rather than inserting a new code block. If existing code is redundant or overcomplicated, replace it \u2014 do not add more code around it.\n6. Edit the most specific method or class that directly handles the vulnerable operation \u2014 not a base class, interface, or Protocol definition.", "role": "system"}, {"content": "# CVE\nCVE-2025-55763: civetweb constructs a redirect URL by appending a query string to an internal buffer using unchecked concatenation, allowing a crafted HTTP request with an overlong query to overflow the buffer and corrupt adjacent memory.\n\n# Vulnerable source (src/civetweb.c)\n```c\n\t\tso->lsa.sin.sin_port = htons((uint16_t)port);\n\t\t*ip_version = 4;\n\n#if defined(USE_IPV6)\n\t} else if (sscanf(vec->ptr, \"[%49[^]]]:%u%n\", buf, &port, &len) == 2\n\t           && ((size_t)len <= vec->len)\n\t           && mg_inet_pton(\n\t                  AF_INET6, buf, &so->lsa.sin6, sizeof(so->lsa.sin6), 0)) {\n\t\t/* IPv6 address, examples: see above */\n\t\t/* so->lsa.sin6.sin6_family = AF_INET6; already set by mg_inet_pton\n\t\t */\n\t\tso->lsa.sin6.sin6_port = htons((uint16_t)port);\n\t\t*ip_version = 6;\n#endif\n\n\t} else if ((vec->ptr[0] == '+')\n\t           && (sscanf(vec->ptr + 1, \"%u%n\", &port, &len)\n\t               == 1)) { // NOLINT(cert-err34-c) 'sscanf' used to convert a\n\t\t                    // string to an integer value, but function will not\n\t\t                    // report conversion errors; consider using 'strtol'\n\t\t                    // instead\n\n\t\t/* Port is specified with a +, bind to IPv6 and IPv4, INADDR_ANY */\n\t\t/* Add 1 to len for the + character we skipped before */\n\t\tlen++;\n\n#if defined(USE_IPV6)\n\t\t/* Set socket family to IPv6, do not use IPV6_V6ONLY */\n\t\tso->lsa.sin6.sin6_family = AF_INET6;\n\t\tso->lsa.sin6.sin6_port = htons((uint16_t)port);\n\t\t*ip_version = 4 + 6;\n#else\n\t\t/* Bind to IPv4 only, since IPv6 is not built in. */\n\t\tso->lsa.sin.sin_port = htons((uint16_t)port);\n\t\t*ip_version = 4;\n#endif\n\n\t} else if (is_valid_port(portUL = strtoul(vec->ptr, &endptr, 0))\n\t           && (vec->ptr != endptr)) {\n\t\tlen = (int)(endptr - vec->ptr);\n\t\tport = (uint16_t)portUL;\n\t\t/* If only port is specified, bind to IPv4, INADDR_ANY */\n\t\tso->lsa.sin.sin_port = htons((uint16_t)port);\n\t\t*ip_version = 4;\n\n\t} else if ((cb = strchr(vec->ptr, ':')) != NULL) {\n\t\t/* String could be a hostname. This check algorithm\n\t\t * will only work for RFC 952 compliant hostnames,\n\t\t * starting with a letter, containing only letters,\n\t\t * digits and hyphen ('-'). Newer specs may allow\n\t\t * more, but this is not guaranteed here, since it\n\t\t * may interfere with rules for port option lists. */\n\n\t\t/* According to RFC 1035, hostnames are restricted to 255 characters\n\t\t * in total (63 between two dots). */\n\t\tchar hostname[256];\n\t\tsize_t hostnlen = (size_t)(cb - vec->ptr);\n\n\t\tif ((hostnlen >= vec->len) || (hostnlen >= sizeof(hostname))) {\n\t\t\t/* This would be invalid in any case */\n\t\t\t*ip_version = 0;\n\t\t\treturn 0;\n\t\t}\n\n\t\tmg_strlcpy(hostname, vec->ptr, hostnlen + 1);\n\n\t\tif (mg_inet_pton(\n\t\t        AF_INET, hostname, &so->lsa.sin, sizeof(so->lsa.sin), 1)) {\n\t\t\tif (sscanf(cb + 1, \"%u%n\", &port, &len)\n\t\t\t    == 1) { // NOLINT(cert-err34-c) 'sscanf' used to convert a\n\t\t\t\t        // string to an integer value, but function will not\n\t\t\t\t        // report conversion errors; consider using 'strtol'\n\t\t\t\t        // instead\n\t\t\t\t*ip_version = 4;\n\t\t\t\tso->lsa.sin.sin_port = htons((uint16_t)port);\n\t\t\t\tlen += (int)(hostnlen + 1);\n\t\t\t} else {\n\t\t\t\tlen = 0;\n\t\t\t}\n#if defined(USE_IPV6)\n\t\t} else if (mg_inet_pton(AF_INET6,\n\t\t                        hostname,\n\t\t                        &so->lsa.sin6,\n\t\t                        sizeof(so->lsa.sin6),\n\t\t                        1)) {\n\t\t\tif (sscanf(cb + 1, \"%u%n\", &port, &len) == 1) {\n\t\t\t\t*ip_version = 6;\n\t\t\t\tso->lsa.sin6.sin6_port = htons((uint16_t)port);\n\t\t\t\tlen += (int)(hostnlen + 1);\n\t\t\t} else {\n\t\t\t\tlen = 0;\n\t\t\t}\n#endif\n\t\t} else {\n\t\t\tlen = 0;\n\t\t}\n\n#if defined(USE_X_DOM_SOCKET)\n\n\t} else if (vec->ptr[0] == 'x') {\n\t\t/* unix (linux) domain socket */\n\t\tif (vec->len < sizeof(so->lsa.sun.sun_path)) {\n\t\t\tlen = vec->len;\n\t\t\tso->lsa.sun.sun_family = AF_UNIX;\n\t\t\tmemset(so->lsa.sun.sun_path, 0, sizeof(so->lsa.sun.sun_path));\n```", "role": "user"}, {"content": "diff --git a/src/civetweb.c b/src/civetweb.c\nindex bbc9aa8be..e969c939f 100644\n--- a/src/civetweb.c\n+++ b/src/civetweb.c\n@@ -15579,7 +15579,6 @@ handle_request(struct mg_connection *conn)\n \t/* 12. Directory uris should end with a slash */\n \tif (file.stat.is_directory && ((uri_len = (int)strlen(ri->local_uri)) > 0)\n \t    && (ri->local_uri[uri_len - 1] != '/')) {\n-\n \t\t/* Path + server root */\n \t\tsize_t buflen = UTF8_PATH_MAX * 2 + 2;\n \t\tchar *new_path;\n@@ -15592,12 +15591,26 @@ handle_request(struct mg_connection *conn)\n \t\t\tmg_send_http_error(conn, 500, \"out or memory\");\n \t\t} else {\n \t\t\tmg_get_request_link(conn, new_path, buflen - 1);\n-\t\t\tstrcat(new_path, \"/\");\n+\n+\t\t\tsize_t len = strlen(new_path);\n+\t\t\tif (len + 1 < buflen) {\n+\t\t\t\tnew_path[len] = '/';\n+\t\t\t\tnew_path[len + 1] = '\\0';\n+\t\t\t\tlen += 1;\n+\t\t\t}\n+\n \t\t\tif (ri->query_string) {\n-\t\t\t\t/* Append ? and query string */\n-\t\t\t\tstrcat(new_path, \"?\");\n-\t\t\t\tstrcat(new_path, ri->query_string);\n+\t\t\t\tif (len + 1 < buflen) {\n+\t\t\t\t\tnew_path[len] = '?';\n+\t\t\t\t\tnew_path[len + 1] = '\\0';\n+\t\t\t\t\tlen += 1;\n+\t\t\t\t}\n+\n+\t\t\t\t/* Append with size of space left for query string + null terminator */\n+\t\t\t\tsize_t max_append = buflen - len - 1;\n+\t\t\t\tstrncat(new_path, ri->query_string, max_append);\n \t\t\t}\n+\n \t\t\tmg_send_http_redirect(conn, new_path, 301);\n \t\t\tmg_free(new_path);\n \t\t}", "role": "assistant"}]}
{"messages": [{"content": "You are a security engineer fixing a CVE. You are given the vulnerability description (symptom only) and the vulnerable source window. Author the MINIMAL fix as a unified diff. Follow these rules exactly:\n1. Target ONLY the file named in the `# Vulnerable source (...)` header \u2014 do not invent or substitute file paths.\n2. Modify ONLY code visible in the shown source window.\n3. Change as few lines as possible; do not rewrite surrounding logic.\n4. Output only the unified diff with no other text.\n5. Prefer the minimal structural change: if an existing condition is missing a check, add it inline to that condition rather than inserting a new code block. If existing code is redundant or overcomplicated, replace it \u2014 do not add more code around it.\n6. Edit the most specific method or class that directly handles the vulnerable operation \u2014 not a base class, interface, or Protocol definition.", "role": "system"}, {"content": "# CVE\nCVE-2026-45186: Expat before 2.8.1 is vulnerable to CVE-2026-45186, a denial of service caused by quadratic runtime during DTD default attribute collision detection. Even moderately sized crafted input can exhaust CPU resources through this mechanism.\n\n# Vulnerable source (lib/xmlparse.c)\n```c\ntypedef struct block {\n  struct block *next;\n  int size;\n  XML_Char s[];\n} BLOCK;\n\ntypedef struct {\n  BLOCK *blocks;\n  BLOCK *freeBlocks;\n  const XML_Char *end;\n  XML_Char *ptr;\n  XML_Char *start;\n  XML_Parser parser;\n} STRING_POOL;\n\n/* The XML_Char before the name is used to determine whether\n   an attribute has been specified. */\ntypedef struct attribute_id {\n  XML_Char *name;\n  PREFIX *prefix;\n  XML_Bool maybeTokenized;\n  XML_Bool xmlns;\n} ATTRIBUTE_ID;\n\ntypedef struct {\n  const ATTRIBUTE_ID *id;\n  XML_Bool isCdata;\n  const XML_Char *value;\n} DEFAULT_ATTRIBUTE;\n\ntypedef struct {\n  unsigned long version;\n  unsigned long hash;\n  const XML_Char *uriName;\n} NS_ATT;\n\ntypedef struct {\n  const XML_Char *name;\n  PREFIX *prefix;\n  const ATTRIBUTE_ID *idAtt;\n  int nDefaultAtts;\n  int allocDefaultAtts;\n  DEFAULT_ATTRIBUTE *defaultAtts;\n} ELEMENT_TYPE;\n\ntypedef struct {\n  HASH_TABLE generalEntities;\n  HASH_TABLE elementTypes;\n  HASH_TABLE attributeIds;\n  HASH_TABLE prefixes;\n  STRING_POOL pool;\n  STRING_POOL entityValuePool;\n  /* false once a parameter entity reference has been skipped */\n  XML_Bool keepProcessing;\n  /* true once an internal or external PE reference has been encountered;\n     this includes the reference to an external subset */\n  XML_Bool hasParamEntityRefs;\n  XML_Bool standalone;\n#ifdef XML_DTD\n  /* indicates if external PE has been read */\n  XML_Bool paramEntityRead;\n  HASH_TABLE paramEntities;\n#endif /* XML_DTD */\n  PREFIX defaultPrefix;\n  /* === scaffolding for building content model === */\n  XML_Bool in_eldecl;\n  CONTENT_SCAFFOLD *scaffold;\n  unsigned contentStringLen;\n  unsigned scaffSize;\n  unsigned scaffCount;\n  int scaffLevel;\n  int *scaffIndex;\n} DTD;\n\nenum EntityType {\n  ENTITY_INTERNAL,\n  ENTITY_ATTRIBUTE,\n  ENTITY_VALUE,\n};\n\ntypedef struct open_internal_entity {\n  const char *internalEventPtr;\n  const char *internalEventEndPtr;\n  struct open_internal_entity *next;\n  ENTITY *entity;\n  int startTagLevel;\n  XML_Bool betweenDecl; /* WFC: PE Between Declarations */\n  enum EntityType type;\n} OPEN_INTERNAL_ENTITY;\n\nenum XML_Account {\n  XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */\n  XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity\n                                   expansion */\n  XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */\n};\n\n#if XML_GE == 1\ntypedef unsigned long long XmlBigCount;\ntypedef struct accounting {\n  XmlBigCount countBytesDirect;\n  XmlBigCount countBytesIndirect;\n  unsigned long debugLevel;\n  float maximumAmplificationFactor; // >=1.0\n  unsigned long long activationThresholdBytes;\n} ACCOUNTING;\n\ntypedef struct MALLOC_TRACKER {\n  XmlBigCount bytesAllocated;\n  XmlBigCount peakBytesAllocated; // updated live only for debug level >=2\n  unsigned long debugLevel;\n  float maximumAmplificationFactor; // >=1.0\n  XmlBigCount activationThresholdBytes;\n} MALLOC_TRACKER;\n\ntypedef struct entity_stats {\n  unsigned int countEverOpened;\n  unsigned int currentDepth;\n  unsigned int maximumDepthSeen;\n  unsigned long debugLevel;\n} ENTITY_STATS;\n#endif /* XML_GE == 1 */\n\ntypedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,\n                                         const char *end, const char **endPtr);\n\nstatic Processor prologProcessor;\nstatic Processor prologInitProcessor;\nstatic Processor contentProcessor;\nstatic Processor cdataSectionProcessor;\n#ifdef XML_DTD\nstatic Processor ignoreSectionProcessor;\nstatic Processor externalParEntProcessor;\nstatic Processor externalParEntInitProcessor;\nstatic Processor entityValueProcessor;\nstatic Processor entityValueInitProcessor;\n#endif /* XML_DTD */\nstatic Processor epilogProcessor;\nstatic Processor errorProcessor;\nstatic Processor externalEntityInitProcessor;\nstatic Processor externalEntityInitProcessor2;\nstatic Processor externalEntityInitProcessor3;\nstatic Processor externalEntityContentProcessor;\nstatic Processor internalEntityProcessor;\n\nstatic enum XML_Error handleUnknownEncoding(XML_Parser parser,\n                                            const XML_Char *encodingName);\nstatic enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,\n                                     const char *s, const char *next);\nstatic enum XML_Error initializeEncoding(XML_Parser parser);\nstatic enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,\n                               const char *s, const char *end, int tok,\n                               const char *next, const char **nextPtr,\n                               XML_Bool haveMore, XML_Bool allowClosingDoctype,\n                               enum XML_Account account);\nstatic enum XML_Error processEntity(XML_Parser parser, ENTITY *entity,\n                                    XML_Bool betweenDecl, enum EntityType type);\nstatic enum XML_Error doContent(XML_Parser parser, int startTagLevel,\n                                const ENCODING *enc, const char *start,\n                                const char *end, const char **endPtr,\n                                XML_Bool haveMore, enum XML_Account account);\nstatic enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,\n                                     const char **startPtr, const char *end,\n                                     const char **nextPtr, XML_Bool haveMore,\n                                     enum XML_Account account);\n#ifdef XML_DTD\nstatic enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,\n                                      const char **startPtr, const char *end,\n                                      const char **nextPtr, XML_Bool haveMore);\n#endif /* XML_DTD */\n\nstatic void freeBindings(XML_Parser parser, BINDING *bindings);\nstatic enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,\n                                const char *attStr, TAG_NAME *tagNamePtr,\n                                BINDING **bindingsPtr,\n                                enum XML_Account account);\nstatic enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,\n                                 const ATTRIBUTE_ID *attId, const XML_Char *uri,\n                                 BINDING **bindingsPtr);\nstatic int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId,\n                           XML_Bool isCdata, XML_Bool isId,\n                           const XML_Char *value, XML_Parser parser);\nstatic enum XML_Error storeAttributeValue(XML_Parser parser,\n                                          const ENCODING *enc, XML_Bool isCdata,\n                                          const char *ptr, const char *end,\n                                          STRING_POOL *pool,\n                                          enum XML_Account account);\nstatic enum XML_Error\nappendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                     const char *ptr, const char *end, STRING_POOL *pool,\n                     enum XML_Account account, const char **nextPtr);\nstatic ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,\n                                    const char *start, const char *end);\nstatic int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType);\n#if XML_GE == 1\nstatic enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,\n                                       const char *start, const char *end,\n                                       enum XML_Account account,\n                                       const char **nextPtr);\nstatic enum XML_Error callStoreEntityValue(XML_Parser parser,\n                                           const ENCODING *enc,\n                                           const char *start, const char *end,\n                                           enum XML_Account account);\n#else\nstatic enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);\n#endif\nstatic int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\n                                       const char *start, const char *end);\nstatic int reportComment(XML_Parser parser, const ENCODING *enc,\n                         const char *start, const char *end);\nstatic void reportDefault(XML_Parser parser, const ENCODING *enc,\n                          const char *start, const char *end);\n\nstatic const XML_Char *getContext(XML_Parser parser);\nstatic XML_Bool setContext(XML_Parser parser, const XML_Char *context);\n\nstatic void FASTCALL normalizePublicId(XML_Char *s);\n\nstatic DTD *dtdCreate(XML_Parser parser);\n/* do not call if m_parentParser != NULL */\nstatic void dtdReset(DTD *p, XML_Parser parser);\nstatic void dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser);\nstatic int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n                   XML_Parser parser);\nstatic int copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,\n                           STRING_POOL *newPool, const HASH_TABLE *oldTable);\nstatic NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,\n                     size_t createSize);\nstatic void FASTCALL hashTableInit(HASH_TABLE *table, XML_Parser parser);\nstatic void FASTCALL hashTableClear(HASH_TABLE *table);\nstatic void FASTCALL hashTableDestroy(HASH_TABLE *table);\nstatic void FASTCALL hashTableIterInit(HASH_TABLE_ITER *iter,\n                                       const HASH_TABLE *table);\nstatic NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *iter);\n\nstatic void FASTCALL poolInit(STRING_POOL *pool, XML_Parser parser);\nstatic void FASTCALL poolClear(STRING_POOL *pool);\nstatic void FASTCALL poolDestroy(STRING_POOL *pool);\nstatic XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,\n                            const char *ptr, const char *end);\nstatic XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,\n                                 const char *ptr, const char *end);\nstatic XML_Bool FASTCALL poolGrow(STRING_POOL *pool);\nstatic const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,\n                                               const XML_Char *s);\nstatic const XML_Char *FASTCALL poolCopyStringNoFinish(STRING_POOL *pool,\n                                                       const XML_Char *s);\nstatic const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,\n                                       int n);\nstatic const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,\n                                                 const XML_Char *s);\n\nstatic int FASTCALL nextScaffoldPart(XML_Parser parser);\nstatic XML_Content *build_model(XML_Parser parser);\nstatic ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,\n                                    const char *ptr, const char *end);\n\nstatic XML_Char *copyString(const XML_Char *s, XML_Parser parser);\n\nstatic struct sipkey generate_hash_secret_salt(void);\nstatic XML_Bool startParsing(XML_Parser parser);\n\nstatic XML_Parser parserCreate(const XML_Char *encodingName,\n                               const XML_Memory_Handling_Suite *memsuite,\n                               const XML_Char *nameSep, DTD *dtd,\n                               XML_Parser parentParser);\n\nstatic void parserInit(XML_Parser parser, const XML_Char *encodingName);\n\n#if XML_GE == 1\nstatic float accountingGetCurrentAmplification(XML_Parser rootParser);\nstatic void accountingReportStats(XML_Parser originParser, const char *epilog);\nstatic void accountingOnAbort(XML_Parser originParser);\nstatic void accountingReportDiff(XML_Parser rootParser,\n                                 unsigned int levelsAwayFromRootParser,\n                                 const char *before, const char *after,\n                                 ptrdiff_t bytesMore, int source_line,\n                                 enum XML_Account account);\nstatic XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,\n                                        const char *before, const char *after,\n                                        int source_line,\n                                        enum XML_Account account);\n\nstatic void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,\n                                      const char *action, int sourceLine);\nstatic void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,\n                                 int sourceLine);\nstatic void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,\n                                  int sourceLine);\n#endif /* XML_GE == 1 */\n\nstatic XML_Parser getRootParserOf(XML_Parser parser,\n                                  unsigned int *outLevelDiff);\n\nstatic unsigned long getDebugLevel(const char *variableName,\n                                   unsigned long defaultDebugLevel);\n\n#define poolStart(pool) ((pool)->start)\n#define poolLength(pool) ((pool)->ptr - (pool)->start)\n#define poolChop(pool) ((void)--(pool->ptr))\n#define poolLastChar(pool) (((pool)->ptr)[-1])\n#define poolDiscard(pool) ((pool)->ptr = (pool)->start)\n#define poolFinish(pool) ((pool)->start = (pool)->ptr)\n#define poolAppendChar(pool, c)                                                \\\n  (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \\\n       ? 0                                                                     \\\n       : ((*((pool)->ptr)++ = c), 1))\n\n#if ! defined(XML_TESTING)\nconst\n#endif\n    XML_Bool g_reparseDeferralEnabledDefault\n    = XML_TRUE; // write ONLY in runtests.c\n#if defined(XML_TESTING)\nunsigned int g_bytesScanned = 0; // used for testing only\n#endif\n\nstruct XML_ParserStruct {\n  /* The first member must be m_userData so that the XML_GetUserData\n     macro works. */\n  void *m_userData;\n  void *m_handlerArg;\n\n  // How the four parse buffer pointers below relate in time and space:\n  //\n  //   m_buffer <= m_bufferPtr <= m_bufferEnd  <= m_bufferLim\n  //   |           |              |               |\n  //   <--parsed-->|              |               |\n  //               <---parsing--->|               |\n  //                              <--unoccupied-->|\n  //   <---------total-malloced/realloced-------->|\n\n  char *m_buffer; // malloc/realloc base pointer of parse buffer\n  const XML_Memory_Handling_Suite m_mem;\n  const char *m_bufferPtr; // first character to be parsed\n  char *m_bufferEnd;       // past last character to be parsed\n  const char *m_bufferLim; // allocated end of m_buffer\n\n  XML_Index m_parseEndByteIndex;\n  const char *m_parseEndPtr;\n  size_t m_partialTokenBytesBefore; /* used in heuristic to avoid O(n^2) */\n  XML_Bool m_reparseDeferralEnabled;\n  int m_lastBufferRequestSize;\n  XML_Char *m_dataBuf;\n  XML_Char *m_dataBufEnd;\n  XML_StartElementHandler m_startElementHandler;\n  XML_EndElementHandler m_endElementHandler;\n  XML_CharacterDataHandler m_characterDataHandler;\n  XML_ProcessingInstructionHandler m_processingInstructionHandler;\n  XML_CommentHandler m_commentHandler;\n  XML_StartCdataSectionHandler m_startCdataSectionHandler;\n  XML_EndCdataSectionHandler m_endCdataSectionHandler;\n  XML_DefaultHandler m_defaultHandler;\n  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;\n  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;\n  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;\n  XML_NotationDeclHandler m_notationDeclHandler;\n  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;\n  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;\n  XML_NotStandaloneHandler m_notStandaloneHandler;\n  XML_ExternalEntityRefHandler m_externalEntityRefHandler;\n  XML_Parser m_externalEntityRefHandlerArg;\n  XML_SkippedEntityHandler m_skippedEntityHandler;\n  XML_UnknownEncodingHandler m_unknownEncodingHandler;\n  XML_ElementDeclHandler m_elementDeclHandler;\n  XML_AttlistDeclHandler m_attlistDeclHandler;\n  XML_EntityDeclHandler m_entityDeclHandler;\n  XML_XmlDeclHandler m_xmlDeclHandler;\n  const ENCODING *m_encoding;\n  INIT_ENCODING m_initEncoding;\n  const ENCODING *m_internalEncoding;\n  const XML_Char *m_protocolEncodingName;\n  XML_Bool m_ns;\n  XML_Bool m_ns_triplets;\n  void *m_unknownEncodingMem;\n  void *m_unknownEncodingData;\n  void *m_unknownEncodingHandlerData;\n  void(XMLCALL *m_unknownEncodingRelease)(void *);\n  PROLOG_STATE m_prologState;\n  Processor *m_processor;\n  enum XML_Error m_errorCode;\n  const char *m_eventPtr;\n  const char *m_eventEndPtr;\n  const char *m_positionPtr;\n  OPEN_INTERNAL_ENTITY *m_openInternalEntities;\n  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;\n  OPEN_INTERNAL_ENTITY *m_openAttributeEntities;\n  OPEN_INTERNAL_ENTITY *m_freeAttributeEntities;\n  OPEN_INTERNAL_ENTITY *m_openValueEntities;\n  OPEN_INTERNAL_ENTITY *m_freeValueEntities;\n  XML_Bool m_defaultExpandInternalEntities;\n  int m_tagLevel;\n  ENTITY *m_declEntity;\n  const XML_Char *m_doctypeName;\n  const XML_Char *m_doctypeSysid;\n  const XML_Char *m_doctypePubid;\n  const XML_Char *m_declAttributeType;\n  const XML_Char *m_declNotationName;\n  const XML_Char *m_declNotationPublicId;\n  ELEMENT_TYPE *m_declElementType;\n  ATTRIBUTE_ID *m_declAttributeId;\n  XML_Bool m_declAttributeIsCdata;\n  XML_Bool m_declAttributeIsId;\n  DTD *m_dtd;\n  const XML_Char *m_curBase;\n  TAG *m_tagStack;\n  TAG *m_freeTagList;\n  BINDING *m_inheritedBindings;\n  BINDING *m_freeBindingList;\n  int m_attsSize;\n  int m_nSpecifiedAtts;\n  int m_idAttIndex;\n  ATTRIBUTE *m_atts;\n  NS_ATT *m_nsAtts;\n  unsigned long m_nsAttsVersion;\n  unsigned char m_nsAttsPower;\n#ifdef XML_ATTR_INFO\n  XML_AttrInfo *m_attInfo;\n#endif\n  POSITION m_position;\n  STRING_POOL m_tempPool;\n  STRING_POOL m_temp2Pool;\n  char *m_groupConnector;\n  unsigned int m_groupSize;\n  XML_Char m_namespaceSeparator;\n  XML_Parser m_parentParser;\n  XML_ParsingStatus m_parsingStatus;\n#ifdef XML_DTD\n  XML_Bool m_isParamEntity;\n  XML_Bool m_useForeignDTD;\n  enum XML_ParamEntityParsing m_paramEntityParsing;\n#endif\n  struct sipkey m_hash_secret_salt_128;\n  XML_Bool m_hash_secret_salt_set;\n#if XML_GE == 1\n  ACCOUNTING m_accounting;\n  MALLOC_TRACKER m_alloc_tracker;\n  ENTITY_STATS m_entity_stats;\n#endif\n  XML_Bool m_reenter;\n};\n\n#if XML_GE == 1\n#  define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__))\n#  define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__))\n#  define FREE(parser, p) (expat_free((parser), (p), __LINE__))\n#else\n#  define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))\n#  define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))\n#  define FREE(parser, p) (parser->m_mem.free_fcn((p)))\n#endif\n\n#if XML_GE == 1\nstatic void\nexpat_heap_stat(XML_Parser rootParser, char operator, XmlBigCount absDiff,\n                XmlBigCount newTotal, XmlBigCount peakTotal, int sourceLine) {\n  // NOTE: This can be +infinity or -nan\n  const float amplification\n      = (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;\n  fprintf(\n      stderr,\n      \"expat: Allocations(%p): Direct \" EXPAT_FMT_ULL(\"10\") \", allocated %c\" EXPAT_FMT_ULL(\n          \"10\") \" to \" EXPAT_FMT_ULL(\"10\") \" (\" EXPAT_FMT_ULL(\"10\") \" peak), amplification %8.2f (xmlparse.c:%d)\\n\",\n      (void *)rootParser, rootParser->m_accounting.countBytesDirect, operator,\n      absDiff, newTotal, peakTotal, (double)amplification, sourceLine);\n}\n\nstatic bool\nexpat_heap_increase_tolerable(XML_Parser rootParser, XmlBigCount increase,\n                              int sourceLine) {\n  assert(rootParser != NULL);\n  assert(increase > 0);\n\n  XmlBigCount newTotal = 0;\n  bool tolerable = true;\n\n  // Detect integer overflow\n  if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated < increase) {\n    tolerable = false;\n  } else {\n    newTotal = rootParser->m_alloc_tracker.bytesAllocated + increase;\n\n    if (newTotal >= rootParser->m_alloc_tracker.activationThresholdBytes) {\n      assert(newTotal > 0);\n      // NOTE: This can be +infinity when dividing by zero but not -nan\n      const float amplification\n          = (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;\n      if (amplification\n          > rootParser->m_alloc_tracker.maximumAmplificationFactor) {\n        tolerable = false;\n      }\n    }\n  }\n\n  if (! tolerable && (rootParser->m_alloc_tracker.debugLevel >= 1)) {\n    expat_heap_stat(rootParser, '+', increase, newTotal, newTotal, sourceLine);\n  }\n\n  return tolerable;\n}\n\n#  if defined(XML_TESTING)\nvoid *\n#  else\nstatic void *\n#  endif\nexpat_malloc(XML_Parser parser, size_t size, int sourceLine) {\n  // Detect integer overflow\n  if (SIZE_MAX - size < sizeof(size_t) + EXPAT_MALLOC_PADDING) {\n    return NULL;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  const size_t bytesToAllocate = sizeof(size_t) + EXPAT_MALLOC_PADDING + size;\n\n  if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated\n      < bytesToAllocate) {\n    return NULL; // i.e. signal integer overflow as out-of-memory\n  }\n\n  if (! expat_heap_increase_tolerable(rootParser, bytesToAllocate,\n                                      sourceLine)) {\n    return NULL; // i.e. signal violation as out-of-memory\n  }\n\n  // Actually allocate\n  void *const mallocedPtr = parser->m_mem.malloc_fcn(bytesToAllocate);\n\n  if (mallocedPtr == NULL) {\n    return NULL;\n  }\n\n  // Update in-block recorded size\n  *(size_t *)mallocedPtr = size;\n\n  // Update accounting\n  rootParser->m_alloc_tracker.bytesAllocated += bytesToAllocate;\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n    expat_heap_stat(rootParser, '+', bytesToAllocate,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING;\n}\n\n#  if defined(XML_TESTING)\nvoid\n#  else\nstatic void\n#  endif\nexpat_free(XML_Parser parser, void *ptr, int sourceLine) {\n  assert(parser != NULL);\n\n  if (ptr == NULL) {\n    return;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  // Extract size (to the eyes of malloc_fcn/realloc_fcn) and\n  // the original pointer returned by malloc/realloc\n  void *const mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);\n  const size_t bytesAllocated\n      = sizeof(size_t) + EXPAT_MALLOC_PADDING + *(size_t *)mallocedPtr;\n\n  // Update accounting\n  assert(rootParser->m_alloc_tracker.bytesAllocated >= bytesAllocated);\n  rootParser->m_alloc_tracker.bytesAllocated -= bytesAllocated;\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    expat_heap_stat(rootParser, '-', bytesAllocated,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  // NOTE: This may be freeing rootParser, so freeing has to come last\n  parser->m_mem.free_fcn(mallocedPtr);\n}\n\n#  if defined(XML_TESTING)\nvoid *\n#  else\nstatic void *\n#  endif\nexpat_realloc(XML_Parser parser, void *ptr, size_t size, int sourceLine) {\n  assert(parser != NULL);\n\n  if (ptr == NULL) {\n    return expat_malloc(parser, size, sourceLine);\n  }\n\n  if (size == 0) {\n    expat_free(parser, ptr, sourceLine);\n    return NULL;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  // Extract original size (to the eyes of the caller) and the original\n  // pointer returned by malloc/realloc\n  void *mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);\n  const size_t prevSize = *(size_t *)mallocedPtr;\n\n  // Classify upcoming change\n  const bool isIncrease = (size > prevSize);\n  const size_t absDiff\n      = (size > prevSize) ? (size - prevSize) : (prevSize - size);\n\n  // Ask for permission from accounting\n  if (isIncrease) {\n    if (! expat_heap_increase_tolerable(rootParser, absDiff, sourceLine)) {\n      return NULL; // i.e. signal violation as out-of-memory\n    }\n  }\n\n  // NOTE: Integer overflow detection has already been done for us\n  //       by expat_heap_increase_tolerable(..) above\n  assert(SIZE_MAX - sizeof(size_t) - EXPAT_MALLOC_PADDING >= size);\n\n  // Actually allocate\n  mallocedPtr = parser->m_mem.realloc_fcn(\n      mallocedPtr, sizeof(size_t) + EXPAT_MALLOC_PADDING + size);\n\n  if (mallocedPtr == NULL) {\n    return NULL;\n  }\n\n  // Update accounting\n  if (isIncrease) {\n    assert((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated\n           >= absDiff);\n    rootParser->m_alloc_tracker.bytesAllocated += absDiff;\n  } else { // i.e. decrease\n    assert(rootParser->m_alloc_tracker.bytesAllocated >= absDiff);\n    rootParser->m_alloc_tracker.bytesAllocated -= absDiff;\n  }\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n    expat_heap_stat(rootParser, isIncrease ? '+' : '-', absDiff,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  // Update in-block recorded size\n  *(size_t *)mallocedPtr = size;\n\n  return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING;\n}\n#endif // XML_GE == 1\n\nXML_Parser XMLCALL\nXML_ParserCreate(const XML_Char *encodingName) {\n  return XML_ParserCreate_MM(encodingName, NULL, NULL);\n}\n\nXML_Parser XMLCALL\nXML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {\n  XML_Char tmp[2] = {nsSep, 0};\n  return XML_ParserCreate_MM(encodingName, NULL, tmp);\n}\n\n// \"xml=http://www.w3.org/XML/1998/namespace\"\nstatic const XML_Char implicitContext[]\n    = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,\n       ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,\n       ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,\n       ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,\n       ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,\n       ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,\n       ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,\n       ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,\n       '\\0'};\n\n#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)\n\nstatic unsigned long\ngather_time_entropy(void) {\n#  ifdef _WIN32\n  FILETIME ft;\n  GetSystemTimeAsFileTime(&ft); /* never fails */\n  return ft.dwHighDateTime ^ ft.dwLowDateTime;\n#  else\n  struct timeval tv;\n  int gettimeofday_res;\n\n  gettimeofday_res = gettimeofday(&tv, NULL);\n\n#    if defined(NDEBUG)\n  (void)gettimeofday_res;\n#    else\n  assert(gettimeofday_res == 0);\n#    endif /* defined(NDEBUG) */\n\n  /* Microseconds time is <20 bits entropy */\n  return tv.tv_usec;\n#  endif\n}\n\n#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */\n\nstatic struct sipkey\nENTROPY_DEBUG(const char *label, struct sipkey entropy_128) {\n  if (getDebugLevel(\"EXPAT_ENTROPY_DEBUG\", 0) >= 1u) {\n    fprintf(stderr,\n            \"expat: Entropy: %s --> [0x\" EXPAT_FMT_LLX(\n                \"016\") \", 0x\" EXPAT_FMT_LLX(\"016\") \"] (16 bytes)\\n\",\n            label, (unsigned long long)entropy_128.k[0],\n            (unsigned long long)entropy_128.k[1]);\n  }\n  return entropy_128;\n}\n\nstatic struct sipkey\ngenerate_hash_secret_salt(void) {\n  struct sipkey entropy;\n\n  /* \"Failproof\" high quality providers: */\n#if defined(HAVE_ARC4RANDOM_BUF)\n  writeRandomBytes_arc4random_buf(&entropy, sizeof(entropy));\n  return ENTROPY_DEBUG(\"arc4random_buf\", entropy);\n#elif defined(HAVE_ARC4RANDOM)\n  writeRandomBytes_arc4random(&entropy, sizeof(entropy));\n  return ENTROPY_DEBUG(\"arc4random\", entropy);\n#else\n  /* Try high quality providers first .. */\n#  ifdef _WIN32\n  if (writeRandomBytes_rand_s(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"rand_s\", entropy);\n  }\n#  elif defined(HAVE_GETENTROPY)\n  if (writeRandomBytes_getentropy(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"getentropy\", entropy);\n  }\n  errno = 0;\n#  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)\n  if (writeRandomBytes_getrandom_nonblock(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"getrandom\", entropy);\n  }\n#  endif\n#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)\n  if (writeRandomBytes_dev_urandom(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"/dev/urandom\", entropy);\n  }\n#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */\n  /* .. and self-made low quality for backup: */\n\n  entropy.k[0] = 0;\n  entropy.k[1] = gather_time_entropy();\n#  if ! defined(__wasi__)\n  /* Process ID is 0 bits entropy if attacker has local access */\n  entropy.k[1] ^= getpid();\n#  endif\n\n  /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */\n  if (sizeof(unsigned long) == 4) {\n    entropy.k[1] *= 2147483647;\n    return ENTROPY_DEBUG(\"fallback(4)\", entropy);\n  } else {\n    entropy.k[1] *= 2305843009213693951ULL;\n    return ENTROPY_DEBUG(\"fallback(8)\", entropy);\n  }\n#endif\n}\n\nstatic enum XML_Error\ncallProcessor(XML_Parser parser, const char *start, const char *end,\n              const char **endPtr) {\n  const size_t have_now = EXPAT_SAFE_PTR_DIFF(end, start);\n\n  if (parser->m_reparseDeferralEnabled\n      && ! parser->m_parsingStatus.finalBuffer) {\n    // Heuristic: don't try to parse a partial token again until the amount of\n    // available data has increased significantly.\n    const size_t had_before = parser->m_partialTokenBytesBefore;\n    // ...but *do* try anyway if we're close to causing a reallocation.\n    size_t available_buffer\n        = EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);\n#if XML_CONTEXT_BYTES > 0\n    available_buffer -= EXPAT_MIN(available_buffer, XML_CONTEXT_BYTES);\n#endif\n    available_buffer\n        += EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd);\n    // m_lastBufferRequestSize is never assigned a value < 0, so the cast is ok\n    const bool enough\n        = (have_now >= 2 * had_before)\n          || ((size_t)parser->m_lastBufferRequestSize > available_buffer);\n\n    if (! enough) {\n      *endPtr = start; // callers may expect this to be set\n      return XML_ERROR_NONE;\n    }\n  }\n#if defined(XML_TESTING)\n  g_bytesScanned += (unsigned)have_now;\n#endif\n  // Run in a loop to eliminate dangerous recursion depths\n  enum XML_Error ret;\n  *endPtr = start;\n  while (1) {\n    // Use endPtr as the new start in each iteration, since it will\n    // be set to the next start point by m_processor.\n    ret = parser->m_processor(parser, *endPtr, end, endPtr);\n\n    // Make parsing status (and in particular XML_SUSPENDED) take\n    // precedence over re-enter flag when they disagree\n    if (parser->m_parsingStatus.parsing != XML_PARSING) {\n      parser->m_reenter = XML_FALSE;\n    }\n\n    if (! parser->m_reenter) {\n      break;\n    }\n\n    parser->m_reenter = XML_FALSE;\n    if (ret != XML_ERROR_NONE)\n      return ret;\n  }\n\n  if (ret == XML_ERROR_NONE) {\n    // if we consumed nothing, remember what we had on this parse attempt.\n    if (*endPtr == start) {\n      parser->m_partialTokenBytesBefore = have_now;\n    } else {\n      parser->m_partialTokenBytesBefore = 0;\n    }\n  }\n  return ret;\n}\n\nstatic XML_Bool /* only valid for root parser */\nstartParsing(XML_Parser parser) {\n  /* hash functions must be initialized before setContext() is called */\n  if (parser->m_hash_secret_salt_set != XML_TRUE) {\n    parser->m_hash_secret_salt_128 = generate_hash_secret_salt();\n    parser->m_hash_secret_salt_set = XML_TRUE;\n  }\n  if (parser->m_ns) {\n    /* implicit context only set for root parser, since child\n       parsers (i.e. external entity parsers) will inherit it\n    */\n    return setContext(parser, implicitContext);\n  }\n  return XML_TRUE;\n}\n\nXML_Parser XMLCALL\nXML_ParserCreate_MM(const XML_Char *encodingName,\n                    const XML_Memory_Handling_Suite *memsuite,\n                    const XML_Char *nameSep) {\n  return parserCreate(encodingName, memsuite, nameSep, NULL, NULL);\n}\n\nstatic XML_Parser\nparserCreate(const XML_Char *encodingName,\n             const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,\n             DTD *dtd, XML_Parser parentParser) {\n  XML_Parser parser = NULL;\n\n#if XML_GE == 1\n  const size_t increase\n      = sizeof(size_t) + EXPAT_MALLOC_PADDING + sizeof(struct XML_ParserStruct);\n\n  if (parentParser != NULL) {\n    const XML_Parser rootParser = getRootParserOf(parentParser, NULL);\n    if (! expat_heap_increase_tolerable(rootParser, increase, __LINE__)) {\n      return NULL;\n    }\n  }\n#else\n  UNUSED_P(parentParser);\n#endif\n\n  if (memsuite) {\n    XML_Memory_Handling_Suite *mtemp;\n#if XML_GE == 1\n    void *const sizeAndParser\n        = memsuite->malloc_fcn(sizeof(size_t) + EXPAT_MALLOC_PADDING\n                               + sizeof(struct XML_ParserStruct));\n    if (sizeAndParser != NULL) {\n      *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct);\n      parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t)\n                            + EXPAT_MALLOC_PADDING);\n#else\n    parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));\n    if (parser != NULL) {\n#endif\n      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\n      mtemp->malloc_fcn = memsuite->malloc_fcn;\n      mtemp->realloc_fcn = memsuite->realloc_fcn;\n      mtemp->free_fcn = memsuite->free_fcn;\n    }\n  } else {\n    XML_Memory_Handling_Suite *mtemp;\n#if XML_GE == 1\n    void *const sizeAndParser = malloc(sizeof(size_t) + EXPAT_MALLOC_PADDING\n                                       + sizeof(struct XML_ParserStruct));\n    if (sizeAndParser != NULL) {\n      *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct);\n      parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t)\n                            + EXPAT_MALLOC_PADDING);\n#else\n    parser = malloc(sizeof(struct XML_ParserStruct));\n    if (parser != NULL) {\n#endif\n      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\n      mtemp->malloc_fcn = malloc;\n      mtemp->realloc_fcn = realloc;\n      mtemp->free_fcn = free;\n    }\n  } // cppcheck-suppress[memleak symbolName=sizeAndParser] // Cppcheck >=2.18.0\n\n  if (! parser)\n    return parser;\n\n#if XML_GE == 1\n  // Initialize .m_alloc_tracker\n  memset(&parser->m_alloc_tracker, 0, sizeof(MALLOC_TRACKER));\n  if (parentParser == NULL) {\n    parser->m_alloc_tracker.debugLevel\n        = getDebugLevel(\"EXPAT_MALLOC_DEBUG\", 0u);\n    parser->m_alloc_tracker.maximumAmplificationFactor\n        = EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT;\n    parser->m_alloc_tracker.activationThresholdBytes\n        = EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT;\n\n    // NOTE: This initialization needs to come this early because these fields\n    //       are read by allocation tracking code\n    parser->m_parentParser = NULL;\n    parser->m_accounting.countBytesDirect = 0;\n  } else {\n    parser->m_parentParser = parentParser;\n  }\n\n  // Record XML_ParserStruct allocation we did a few lines up before\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n  assert(SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated >= increase);\n  rootParser->m_alloc_tracker.bytesAllocated += increase;\n\n  // Report on allocation\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n\n    expat_heap_stat(rootParser, '+', increase,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, __LINE__);\n  }\n#else\n  parser->m_parentParser = NULL;\n#endif // XML_GE == 1\n\n  parser->m_buffer = NULL;\n  parser->m_bufferLim = NULL;\n\n  parser->m_attsSize = INIT_ATTS_SIZE;\n  parser->m_atts = MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));\n  if (parser->m_atts == NULL) {\n    FREE(parser, parser);\n    return NULL;\n  }\n#ifdef XML_ATTR_INFO\n  parser->m_attInfo = MALLOC(parser, parser->m_attsSize * sizeof(XML_AttrInfo));\n  if (parser->m_attInfo == NULL) {\n    FREE(parser, parser->m_atts);\n    FREE(parser, parser);\n    return NULL;\n  }\n#endif\n  parser->m_dataBuf = MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));\n  if (parser->m_dataBuf == NULL) {\n    FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n    FREE(parser, parser->m_attInfo);\n#endif\n    FREE(parser, parser);\n    return NULL;\n  }\n  parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;\n\n  if (dtd)\n    parser->m_dtd = dtd;\n  else {\n    parser->m_dtd = dtdCreate(parser);\n    if (parser->m_dtd == NULL) {\n      FREE(parser, parser->m_dataBuf);\n      FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n      FREE(parser, parser->m_attInfo);\n#endif\n      FREE(parser, parser);\n      return NULL;\n    }\n  }\n\n  parser->m_freeBindingList = NULL;\n  parser->m_freeTagList = NULL;\n  parser->m_freeInternalEntities = NULL;\n  parser->m_freeAttributeEntities = NULL;\n  parser->m_freeValueEntities = NULL;\n\n  parser->m_groupSize = 0;\n  parser->m_groupConnector = NULL;\n\n  parser->m_unknownEncodingHandler = NULL;\n  parser->m_unknownEncodingHandlerData = NULL;\n\n  parser->m_namespaceSeparator = ASCII_EXCL;\n  parser->m_ns = XML_FALSE;\n  parser->m_ns_triplets = XML_FALSE;\n\n  parser->m_nsAtts = NULL;\n  parser->m_nsAttsVersion = 0;\n  parser->m_nsAttsPower = 0;\n\n  parser->m_protocolEncodingName = NULL;\n\n  poolInit(&parser->m_tempPool, parser);\n  poolInit(&parser->m_temp2Pool, parser);\n  parserInit(parser, encodingName);\n\n  if (encodingName && ! parser->m_protocolEncodingName) {\n    if (dtd) {\n      // We need to stop the upcoming call to XML_ParserFree from happily\n      // destroying parser->m_dtd because the DTD is shared with the parent\n      // parser and the only guard that keeps XML_ParserFree from destroying\n      // parser->m_dtd is parser->m_isParamEntity but it will be set to\n      // XML_TRUE only later in XML_ExternalEntityParserCreate (or not at all).\n      parser->m_dtd = NULL;\n    }\n    XML_ParserFree(parser);\n    return NULL;\n  }\n\n  if (nameSep) {\n    parser->m_ns = XML_TRUE;\n    parser->m_internalEncoding = XmlGetInternalEncodingNS();\n    parser->m_namespaceSeparator = *nameSep;\n  } else {\n    parser->m_internalEncoding = XmlGetInternalEncoding();\n  }\n\n  return parser;\n}\n\nstatic void\nparserInit(XML_Parser parser, const XML_Char *encodingName) {\n  parser->m_processor = prologInitProcessor;\n  XmlPrologStateInit(&parser->m_prologState);\n  if (encodingName != NULL) {\n    parser->m_protocolEncodingName = copyString(encodingName, parser);\n  }\n  parser->m_curBase = NULL;\n  XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);\n  parser->m_userData = NULL;\n  parser->m_handlerArg = NULL;\n  parser->m_startElementHandler = NULL;\n  parser->m_endElementHandler = NULL;\n  parser->m_characterDataHandler = NULL;\n  parser->m_processingInstructionHandler = NULL;\n  parser->m_commentHandler = NULL;\n  parser->m_startCdataSectionHandler = NULL;\n  parser->m_endCdataSectionHandler = NULL;\n  parser->m_defaultHandler = NULL;\n  parser->m_startDoctypeDeclHandler = NULL;\n  parser->m_endDoctypeDeclHandler = NULL;\n  parser->m_unparsedEntityDeclHandler = NULL;\n  parser->m_notationDeclHandler = NULL;\n  parser->m_startNamespaceDeclHandler = NULL;\n  parser->m_endNamespaceDeclHandler = NULL;\n  parser->m_notStandaloneHandler = NULL;\n  parser->m_externalEntityRefHandler = NULL;\n  parser->m_externalEntityRefHandlerArg = parser;\n  parser->m_skippedEntityHandler = NULL;\n  parser->m_elementDeclHandler = NULL;\n  parser->m_attlistDeclHandler = NULL;\n  parser->m_entityDeclHandler = NULL;\n  parser->m_xmlDeclHandler = NULL;\n  parser->m_bufferPtr = parser->m_buffer;\n  parser->m_bufferEnd = parser->m_buffer;\n  parser->m_parseEndByteIndex = 0;\n  parser->m_parseEndPtr = NULL;\n  parser->m_partialTokenBytesBefore = 0;\n  parser->m_reparseDeferralEnabled = g_reparseDeferralEnabledDefault;\n  parser->m_lastBufferRequestSize = 0;\n  parser->m_declElementType = NULL;\n  parser->m_declAttributeId = NULL;\n  parser->m_declEntity = NULL;\n  parser->m_doctypeName = NULL;\n  parser->m_doctypeSysid = NULL;\n  parser->m_doctypePubid = NULL;\n  parser->m_declAttributeType = NULL;\n  parser->m_declNotationName = NULL;\n  parser->m_declNotationPublicId = NULL;\n  parser->m_declAttributeIsCdata = XML_FALSE;\n  parser->m_declAttributeIsId = XML_FALSE;\n  memset(&parser->m_position, 0, sizeof(POSITION));\n  parser->m_errorCode = XML_ERROR_NONE;\n  parser->m_eventPtr = NULL;\n  parser->m_eventEndPtr = NULL;\n  parser->m_positionPtr = NULL;\n  parser->m_openInternalEntities = NULL;\n  parser->m_openAttributeEntities = NULL;\n  parser->m_openValueEntities = NULL;\n  parser->m_defaultExpandInternalEntities = XML_TRUE;\n  parser->m_tagLevel = 0;\n  parser->m_tagStack = NULL;\n  parser->m_inheritedBindings = NULL;\n  parser->m_nSpecifiedAtts = 0;\n  parser->m_unknownEncodingMem = NULL;\n  parser->m_unknownEncodingRelease = NULL;\n  parser->m_unknownEncodingData = NULL;\n  parser->m_parsingStatus.parsing = XML_INITIALIZED;\n  // Reentry can only be triggered inside m_processor calls\n  parser->m_reenter = XML_FALSE;\n#ifdef XML_DTD\n  parser->m_isParamEntity = XML_FALSE;\n  parser->m_useForeignDTD = XML_FALSE;\n  parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\n#endif\n  parser->m_hash_secret_salt_128.k[0] = 0;\n  parser->m_hash_secret_salt_128.k[1] = 0;\n  parser->m_hash_secret_salt_set = XML_FALSE;\n\n#if XML_GE == 1\n  memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));\n  parser->m_accounting.debugLevel = getDebugLevel(\"EXPAT_ACCOUNTING_DEBUG\", 0u);\n  parser->m_accounting.maximumAmplificationFactor\n      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT;\n  parser->m_accounting.activationThresholdBytes\n      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT;\n\n  memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));\n  parser->m_entity_stats.debugLevel = getDebugLevel(\"EXPAT_ENTITY_DEBUG\", 0u);\n#endif\n}\n\n/* moves list of bindings to m_freeBindingList */\nstatic void FASTCALL\nmoveToFreeBindingList(XML_Parser parser, BINDING *bindings) {\n  while (bindings) {\n    BINDING *b = bindings;\n    bindings = bindings->nextTagBinding;\n    b->nextTagBinding = parser->m_freeBindingList;\n    parser->m_freeBindingList = b;\n  }\n}\n\nXML_Bool XMLCALL\nXML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {\n  TAG *tStk;\n  OPEN_INTERNAL_ENTITY *openEntityList;\n\n  if (parser == NULL)\n    return XML_FALSE;\n\n  if (parser->m_parentParser)\n    return XML_FALSE;\n  /* move m_tagStack to m_freeTagList */\n  tStk = parser->m_tagStack;\n  while (tStk) {\n    TAG *tag = tStk;\n    tStk = tStk->parent;\n    tag->parent = parser->m_freeTagList;\n    moveToFreeBindingList(parser, tag->bindings);\n    tag->bindings = NULL;\n    parser->m_freeTagList = tag;\n  }\n  /* move m_openInternalEntities to m_freeInternalEntities */\n  openEntityList = parser->m_openInternalEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeInternalEntities;\n    parser->m_freeInternalEntities = openEntity;\n  }\n  /* move m_openAttributeEntities to m_freeAttributeEntities (i.e. same task but\n   * for attributes) */\n  openEntityList = parser->m_openAttributeEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeAttributeEntities;\n    parser->m_freeAttributeEntities = openEntity;\n  }\n  /* move m_openValueEntities to m_freeValueEntities (i.e. same task but\n   * for value entities) */\n  openEntityList = parser->m_openValueEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeValueEntities;\n    parser->m_freeValueEntities = openEntity;\n  }\n  moveToFreeBindingList(parser, parser->m_inheritedBindings);\n  FREE(parser, parser->m_unknownEncodingMem);\n  if (parser->m_unknownEncodingRelease)\n    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);\n  poolClear(&parser->m_tempPool);\n  poolClear(&parser->m_temp2Pool);\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n  parser->m_protocolEncodingName = NULL;\n  parserInit(parser, encodingName);\n  dtdReset(parser->m_dtd, parser);\n  return XML_TRUE;\n}\n\nstatic XML_Bool\nparserBusy(XML_Parser parser) {\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_PARSING:\n  case XML_SUSPENDED:\n    return XML_TRUE;\n  case XML_INITIALIZED:\n  case XML_FINISHED:\n  default:\n    return XML_FALSE;\n  }\n}\n\nenum XML_Status XMLCALL\nXML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  /* Block after XML_Parse()/XML_ParseBuffer() has been called.\n     XXX There's no way for the caller to determine which of the\n     XXX possible error cases caused the XML_STATUS_ERROR return.\n  */\n  if (parserBusy(parser))\n    return XML_STATUS_ERROR;\n\n  /* Get rid of any previous encoding name */\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n\n  if (encodingName == NULL)\n    /* No new encoding name */\n    parser->m_protocolEncodingName = NULL;\n  else {\n    /* Copy the new encoding name into allocated memory */\n    parser->m_protocolEncodingName = copyString(encodingName, parser);\n    if (! parser->m_protocolEncodingName)\n      return XML_STATUS_ERROR;\n  }\n  return XML_STATUS_OK;\n}\n\nXML_Parser XMLCALL\nXML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,\n                               const XML_Char *encodingName) {\n  XML_Parser parser = oldParser;\n  DTD *newDtd = NULL;\n  DTD *oldDtd;\n  XML_StartElementHandler oldStartElementHandler;\n  XML_EndElementHandler oldEndElementHandler;\n  XML_CharacterDataHandler oldCharacterDataHandler;\n  XML_ProcessingInstructionHandler oldProcessingInstructionHandler;\n  XML_CommentHandler oldCommentHandler;\n  XML_StartCdataSectionHandler oldStartCdataSectionHandler;\n  XML_EndCdataSectionHandler oldEndCdataSectionHandler;\n  XML_DefaultHandler oldDefaultHandler;\n  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;\n  XML_NotationDeclHandler oldNotationDeclHandler;\n  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;\n  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;\n  XML_NotStandaloneHandler oldNotStandaloneHandler;\n  XML_ExternalEntityRefHandler oldExternalEntityRefHandler;\n  XML_SkippedEntityHandler oldSkippedEntityHandler;\n  XML_UnknownEncodingHandler oldUnknownEncodingHandler;\n  void *oldUnknownEncodingHandlerData;\n  XML_ElementDeclHandler oldElementDeclHandler;\n  XML_AttlistDeclHandler oldAttlistDeclHandler;\n  XML_EntityDeclHandler oldEntityDeclHandler;\n  XML_XmlDeclHandler oldXmlDeclHandler;\n  ELEMENT_TYPE *oldDeclElementType;\n\n  void *oldUserData;\n  void *oldHandlerArg;\n  XML_Bool oldDefaultExpandInternalEntities;\n  XML_Parser oldExternalEntityRefHandlerArg;\n#ifdef XML_DTD\n  enum XML_ParamEntityParsing oldParamEntityParsing;\n  int oldInEntityValue;\n#endif\n  XML_Bool oldns_triplets;\n  /* Note that the new parser shares the same hash secret as the old\n     parser, so that dtdCopy and copyEntityTable can lookup values\n     from hash tables associated with either parser without us having\n     to worry which hash secrets each table has.\n  */\n  struct sipkey oldhash_secret_salt_128;\n  XML_Bool oldhash_secret_salt_set;\n  XML_Bool oldReparseDeferralEnabled;\n\n  /* Validate the oldParser parameter before we pull everything out of it */\n  if (oldParser == NULL)\n    return NULL;\n\n  /* Stash the original parser contents on the stack */\n  oldDtd = parser->m_dtd;\n  oldStartElementHandler = parser->m_startElementHandler;\n  oldEndElementHandler = parser->m_endElementHandler;\n  oldCharacterDataHandler = parser->m_characterDataHandler;\n  oldProcessingInstructionHandler = parser->m_processingInstructionHandler;\n  oldCommentHandler = parser->m_commentHandler;\n  oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;\n  oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;\n  oldDefaultHandler = parser->m_defaultHandler;\n  oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;\n  oldNotationDeclHandler = parser->m_notationDeclHandler;\n  oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;\n  oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;\n  oldNotStandaloneHandler = parser->m_notStandaloneHandler;\n  oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;\n  oldSkippedEntityHandler = parser->m_skippedEntityHandler;\n  oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;\n  oldUnknownEncodingHandlerData = parser->m_unknownEncodingHandlerData;\n  oldElementDeclHandler = parser->m_elementDeclHandler;\n  oldAttlistDeclHandler = parser->m_attlistDeclHandler;\n  oldEntityDeclHandler = parser->m_entityDeclHandler;\n  oldXmlDeclHandler = parser->m_xmlDeclHandler;\n  oldDeclElementType = parser->m_declElementType;\n\n  oldUserData = parser->m_userData;\n  oldHandlerArg = parser->m_handlerArg;\n  oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;\n  oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;\n#ifdef XML_DTD\n  oldParamEntityParsing = parser->m_paramEntityParsing;\n  oldInEntityValue = parser->m_prologState.inEntityValue;\n#endif\n  oldns_triplets = parser->m_ns_triplets;\n  /* Note that the new parser shares the same hash secret as the old\n     parser, so that dtdCopy and copyEntityTable can lookup values\n     from hash tables associated with either parser without us having\n     to worry which hash secrets each table has.\n  */\n  oldhash_secret_salt_128 = parser->m_hash_secret_salt_128;\n  oldhash_secret_salt_set = parser->m_hash_secret_salt_set;\n  oldReparseDeferralEnabled = parser->m_reparseDeferralEnabled;\n\n#ifdef XML_DTD\n  if (! context)\n    newDtd = oldDtd;\n#endif /* XML_DTD */\n\n  /* Note that the magical uses of the pre-processor to make field\n     access look more like C++ require that `parser' be overwritten\n     here.  This makes this function more painful to follow than it\n     would be otherwise.\n  */\n  if (parser->m_ns) {\n    XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};\n    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd, oldParser);\n  } else {\n    parser\n        = parserCreate(encodingName, &parser->m_mem, NULL, newDtd, oldParser);\n  }\n\n  if (! parser)\n    return NULL;\n\n  parser->m_startElementHandler = oldStartElementHandler;\n  parser->m_endElementHandler = oldEndElementHandler;\n  parser->m_characterDataHandler = oldCharacterDataHandler;\n  parser->m_processingInstructionHandler = oldProcessingInstructionHandler;\n  parser->m_commentHandler = oldCommentHandler;\n  parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;\n  parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;\n  parser->m_defaultHandler = oldDefaultHandler;\n  parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;\n  parser->m_notationDeclHandler = oldNotationDeclHandler;\n  parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;\n  parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;\n  parser->m_notStandaloneHandler = oldNotStandaloneHandler;\n  parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;\n  parser->m_skippedEntityHandler = oldSkippedEntityHandler;\n  parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;\n  parser->m_unknownEncodingHandlerData = oldUnknownEncodingHandlerData;\n  parser->m_elementDeclHandler = oldElementDeclHandler;\n  parser->m_attlistDeclHandler = oldAttlistDeclHandler;\n  parser->m_entityDeclHandler = oldEntityDeclHandler;\n  parser->m_xmlDeclHandler = oldXmlDeclHandler;\n  parser->m_declElementType = oldDeclElementType;\n  parser->m_userData = oldUserData;\n  if (oldUserData == oldHandlerArg)\n    parser->m_handlerArg = parser->m_userData;\n  else\n    parser->m_handlerArg = parser;\n  if (oldExternalEntityRefHandlerArg != oldParser)\n    parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;\n  parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;\n  parser->m_ns_triplets = oldns_triplets;\n  parser->m_hash_secret_salt_128 = oldhash_secret_salt_128;\n  parser->m_hash_secret_salt_set = oldhash_secret_salt_set;\n  parser->m_reparseDeferralEnabled = oldReparseDeferralEnabled;\n  parser->m_parentParser = oldParser;\n#ifdef XML_DTD\n  parser->m_paramEntityParsing = oldParamEntityParsing;\n  parser->m_prologState.inEntityValue = oldInEntityValue;\n  if (context) {\n#endif /* XML_DTD */\n    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, parser)\n        || ! setContext(parser, context)) {\n      XML_ParserFree(parser);\n      return NULL;\n    }\n    parser->m_processor = externalEntityInitProcessor;\n#ifdef XML_DTD\n  } else {\n    /* The DTD instance referenced by parser->m_dtd is shared between the\n       document's root parser and external PE parsers, therefore one does not\n       need to call setContext. In addition, one also *must* not call\n       setContext, because this would overwrite existing prefix->binding\n       pointers in parser->m_dtd with ones that get destroyed with the external\n       PE parser. This would leave those prefixes with dangling pointers.\n    */\n    parser->m_isParamEntity = XML_TRUE;\n    XmlPrologStateInitExternalEntity(&parser->m_prologState);\n    parser->m_processor = externalParEntInitProcessor;\n  }\n#endif /* XML_DTD */\n  return parser;\n}\n\nstatic void FASTCALL\ndestroyBindings(BINDING *bindings, XML_Parser parser) {\n  for (;;) {\n    BINDING *b = bindings;\n    if (! b)\n      break;\n    bindings = b->nextTagBinding;\n    FREE(parser, b->uri);\n    FREE(parser, b);\n  }\n}\n\nvoid XMLCALL\nXML_ParserFree(XML_Parser parser) {\n  TAG *tagList;\n  OPEN_INTERNAL_ENTITY *entityList;\n  if (parser == NULL)\n    return;\n  /* free m_tagStack and m_freeTagList */\n  tagList = parser->m_tagStack;\n  for (;;) {\n    TAG *p;\n    if (tagList == NULL) {\n      if (parser->m_freeTagList == NULL)\n        break;\n      tagList = parser->m_freeTagList;\n      parser->m_freeTagList = NULL;\n    }\n    p = tagList;\n    tagList = tagList->parent;\n    FREE(parser, p->buf.raw);\n    destroyBindings(p->bindings, parser);\n    FREE(parser, p);\n  }\n  /* free m_openInternalEntities and m_freeInternalEntities */\n  entityList = parser->m_openInternalEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeInternalEntities == NULL)\n        break;\n      entityList = parser->m_freeInternalEntities;\n      parser->m_freeInternalEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  /* free m_openAttributeEntities and m_freeAttributeEntities */\n  entityList = parser->m_openAttributeEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeAttributeEntities == NULL)\n        break;\n      entityList = parser->m_freeAttributeEntities;\n      parser->m_freeAttributeEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  /* free m_openValueEntities and m_freeValueEntities */\n  entityList = parser->m_openValueEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeValueEntities == NULL)\n        break;\n      entityList = parser->m_freeValueEntities;\n      parser->m_freeValueEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  destroyBindings(parser->m_freeBindingList, parser);\n  destroyBindings(parser->m_inheritedBindings, parser);\n  poolDestroy(&parser->m_tempPool);\n  poolDestroy(&parser->m_temp2Pool);\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n#ifdef XML_DTD\n  /* external parameter entity parsers share the DTD structure\n     parser->m_dtd with the root parser, so we must not destroy it\n  */\n  if (! parser->m_isParamEntity && parser->m_dtd)\n#else\n  if (parser->m_dtd)\n#endif /* XML_DTD */\n    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser, parser);\n  FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n  FREE(parser, parser->m_attInfo);\n#endif\n  FREE(parser, parser->m_groupConnector);\n  // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n  //       is not being allocated with MALLOC(..) but with plain\n  //       .malloc_fcn(..).\n  parser->m_mem.free_fcn(parser->m_buffer);\n  FREE(parser, parser->m_dataBuf);\n  FREE(parser, parser->m_nsAtts);\n  FREE(parser, parser->m_unknownEncodingMem);\n  if (parser->m_unknownEncodingRelease)\n    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);\n  FREE(parser, parser);\n}\n\nvoid XMLCALL\nXML_UseParserAsHandlerArg(XML_Parser parser) {\n  if (parser != NULL)\n    parser->m_handlerArg = parser;\n}\n\nenum XML_Error XMLCALL\nXML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {\n  if (parser == NULL)\n    return XML_ERROR_INVALID_ARGUMENT;\n#ifdef XML_DTD\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;\n  parser->m_useForeignDTD = useDTD;\n  return XML_ERROR_NONE;\n#else\n  UNUSED_P(useDTD);\n  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;\n#endif\n}\n\nvoid XMLCALL\nXML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {\n  if (parser == NULL)\n    return;\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return;\n  parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;\n}\n\nvoid XMLCALL\nXML_SetUserData(XML_Parser parser, void *p) {\n  if (parser == NULL)\n    return;\n  if (parser->m_handlerArg == parser->m_userData)\n    parser->m_handlerArg = parser->m_userData = p;\n  else\n    parser->m_userData = p;\n}\n\nenum XML_Status XMLCALL\nXML_SetBase(XML_Parser parser, const XML_Char *p) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  if (p) {\n    p = poolCopyString(&parser->m_dtd->pool, p);\n    if (! p)\n      return XML_STATUS_ERROR;\n    parser->m_curBase = p;\n  } else\n    parser->m_curBase = NULL;\n  return XML_STATUS_OK;\n}\n\nconst XML_Char *XMLCALL\nXML_GetBase(XML_Parser parser) {\n  if (parser == NULL)\n    return NULL;\n  return parser->m_curBase;\n}\n\nint XMLCALL\nXML_GetSpecifiedAttributeCount(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  return parser->m_nSpecifiedAtts;\n}\n\nint XMLCALL\nXML_GetIdAttributeIndex(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  return parser->m_idAttIndex;\n}\n\n#ifdef XML_ATTR_INFO\nconst XML_AttrInfo *XMLCALL\nXML_GetAttributeInfo(XML_Parser parser) {\n  if (parser == NULL)\n    return NULL;\n  return parser->m_attInfo;\n}\n#endif\n\nvoid XMLCALL\nXML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,\n                      XML_EndElementHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startElementHandler = start;\n  parser->m_endElementHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {\n  if (parser != NULL)\n    parser->m_startElementHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {\n  if (parser != NULL)\n    parser->m_endElementHandler = end;\n}\n\nvoid XMLCALL\nXML_SetCharacterDataHandler(XML_Parser parser,\n                            XML_CharacterDataHandler handler) {\n  if (parser != NULL)\n    parser->m_characterDataHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetProcessingInstructionHandler(XML_Parser parser,\n                                    XML_ProcessingInstructionHandler handler) {\n  if (parser != NULL)\n    parser->m_processingInstructionHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {\n  if (parser != NULL)\n    parser->m_commentHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetCdataSectionHandler(XML_Parser parser,\n                           XML_StartCdataSectionHandler start,\n                           XML_EndCdataSectionHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startCdataSectionHandler = start;\n  parser->m_endCdataSectionHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartCdataSectionHandler(XML_Parser parser,\n                                XML_StartCdataSectionHandler start) {\n  if (parser != NULL)\n    parser->m_startCdataSectionHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndCdataSectionHandler(XML_Parser parser,\n                              XML_EndCdataSectionHandler end) {\n  if (parser != NULL)\n    parser->m_endCdataSectionHandler = end;\n}\n\nvoid XMLCALL\nXML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {\n  if (parser == NULL)\n    return;\n  parser->m_defaultHandler = handler;\n  parser->m_defaultExpandInternalEntities = XML_FALSE;\n}\n\nvoid XMLCALL\nXML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {\n  if (parser == NULL)\n    return;\n  parser->m_defaultHandler = handler;\n  parser->m_defaultExpandInternalEntities = XML_TRUE;\n}\n\nvoid XMLCALL\nXML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,\n                          XML_EndDoctypeDeclHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startDoctypeDeclHandler = start;\n  parser->m_endDoctypeDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartDoctypeDeclHandler(XML_Parser parser,\n                               XML_StartDoctypeDeclHandler start) {\n  if (parser != NULL)\n    parser->m_startDoctypeDeclHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {\n  if (parser != NULL)\n    parser->m_endDoctypeDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetUnparsedEntityDeclHandler(XML_Parser parser,\n                                 XML_UnparsedEntityDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_unparsedEntityDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_notationDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetNamespaceDeclHandler(XML_Parser parser,\n                            XML_StartNamespaceDeclHandler start,\n                            XML_EndNamespaceDeclHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startNamespaceDeclHandler = start;\n  parser->m_endNamespaceDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartNamespaceDeclHandler(XML_Parser parser,\n                                 XML_StartNamespaceDeclHandler start) {\n  if (parser != NULL)\n    parser->m_startNamespaceDeclHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndNamespaceDeclHandler(XML_Parser parser,\n                               XML_EndNamespaceDeclHandler end) {\n  if (parser != NULL)\n    parser->m_endNamespaceDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetNotStandaloneHandler(XML_Parser parser,\n                            XML_NotStandaloneHandler handler) {\n  if (parser != NULL)\n    parser->m_notStandaloneHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetExternalEntityRefHandler(XML_Parser parser,\n                                XML_ExternalEntityRefHandler handler) {\n  if (parser != NULL)\n    parser->m_externalEntityRefHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {\n  if (parser == NULL)\n    return;\n  if (arg)\n    parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;\n  else\n    parser->m_externalEntityRefHandlerArg = parser;\n}\n\nvoid XMLCALL\nXML_SetSkippedEntityHandler(XML_Parser parser,\n                            XML_SkippedEntityHandler handler) {\n  if (parser != NULL)\n    parser->m_skippedEntityHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetUnknownEncodingHandler(XML_Parser parser,\n                              XML_UnknownEncodingHandler handler, void *data) {\n  if (parser == NULL)\n    return;\n  parser->m_unknownEncodingHandler = handler;\n  parser->m_unknownEncodingHandlerData = data;\n}\n\nvoid XMLCALL\nXML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {\n  if (parser != NULL)\n    parser->m_elementDeclHandler = eldecl;\n}\n\nvoid XMLCALL\nXML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {\n  if (parser != NULL)\n    parser->m_attlistDeclHandler = attdecl;\n}\n\nvoid XMLCALL\nXML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_entityDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_xmlDeclHandler = handler;\n}\n\nint XMLCALL\nXML_SetParamEntityParsing(XML_Parser parser,\n                          enum XML_ParamEntityParsing peParsing) {\n  if (parser == NULL)\n    return 0;\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return 0;\n#ifdef XML_DTD\n  parser->m_paramEntityParsing = peParsing;\n  return 1;\n#else\n  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;\n#endif\n}\n\n// DEPRECATED since Expat 2.8.0.\nint XMLCALL\nXML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {\n  if (parser == NULL)\n    return 0;\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(rootParser))\n    return 0;\n\n  rootParser->m_hash_secret_salt_128.k[0] = 0;\n  rootParser->m_hash_secret_salt_128.k[1] = hash_salt;\n\n  if (hash_salt != 0) { // to remain backwards compatible\n    rootParser->m_hash_secret_salt_set = XML_TRUE;\n\n    if (sizeof(unsigned long) == 4)\n      ENTROPY_DEBUG(\"explicit(4)\", rootParser->m_hash_secret_salt_128);\n    else\n      ENTROPY_DEBUG(\"explicit(8)\", rootParser->m_hash_secret_salt_128);\n  }\n\n  return 1;\n}\n\nXML_Bool XMLCALL\nXML_SetHashSalt16Bytes(XML_Parser parser, const uint8_t entropy[16]) {\n  if (parser == NULL)\n    return XML_FALSE;\n\n  if (entropy == NULL)\n    return XML_FALSE;\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(rootParser))\n    return XML_FALSE;\n\n  sip_tokey(&(rootParser->m_hash_secret_salt_128), entropy);\n\n  rootParser->m_hash_secret_salt_set = XML_TRUE;\n\n  ENTROPY_DEBUG(\"explicit(16)\", rootParser->m_hash_secret_salt_128);\n\n  return XML_TRUE;\n}\n\nenum XML_Status XMLCALL\nXML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {\n  if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {\n    if (parser != NULL)\n      parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;\n    return XML_STATUS_ERROR;\n  }\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return XML_STATUS_ERROR;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_INITIALIZED:\n    if (parser->m_parentParser == NULL && ! startParsing(parser)) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return XML_STATUS_ERROR;\n    }\n    /* fall through */\n  default:\n    parser->m_parsingStatus.parsing = XML_PARSING;\n  }\n\n#if XML_CONTEXT_BYTES == 0\n  if (parser->m_bufferPtr == parser->m_bufferEnd) {\n    const char *end;\n    int nLeftOver;\n    enum XML_Status result;\n    /* Detect overflow (a+b > MAX <==> b > MAX-a) */\n    if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n      parser->m_processor = errorProcessor;\n      return XML_STATUS_ERROR;\n    }\n    // though this isn't a buffer request, we assume that `len` is the app's\n    // preferred buffer fill size, and therefore save it here.\n    parser->m_lastBufferRequestSize = len;\n    parser->m_parseEndByteIndex += len;\n    parser->m_positionPtr = s;\n    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;\n\n    parser->m_errorCode\n        = callProcessor(parser, s, parser->m_parseEndPtr = s + len, &end);\n\n    if (parser->m_errorCode != XML_ERROR_NONE) {\n      parser->m_eventEndPtr = parser->m_eventPtr;\n      parser->m_processor = errorProcessor;\n      return XML_STATUS_ERROR;\n    } else {\n      switch (parser->m_parsingStatus.parsing) {\n      case XML_SUSPENDED:\n        result = XML_STATUS_SUSPENDED;\n        break;\n      case XML_INITIALIZED:\n      case XML_PARSING:\n        if (isFinal) {\n          parser->m_parsingStatus.parsing = XML_FINISHED;\n          return XML_STATUS_OK;\n        }\n      /* fall through */\n      default:\n        result = XML_STATUS_OK;\n      }\n    }\n\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,\n                      &parser->m_position);\n    nLeftOver = s + len - end;\n    if (nLeftOver) {\n      // Back up and restore the parsing status to avoid XML_ERROR_SUSPENDED\n      // (and XML_ERROR_FINISHED) from XML_GetBuffer.\n      const enum XML_Parsing originalStatus = parser->m_parsingStatus.parsing;\n      parser->m_parsingStatus.parsing = XML_PARSING;\n      void *const temp = XML_GetBuffer(parser, nLeftOver);\n      parser->m_parsingStatus.parsing = originalStatus;\n      // GetBuffer may have overwritten this, but we want to remember what the\n      // app requested, not how many bytes were left over after parsing.\n      parser->m_lastBufferRequestSize = len;\n      if (temp == NULL) {\n        // NOTE: parser->m_errorCode has already been set by XML_GetBuffer().\n        parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n        parser->m_processor = errorProcessor;\n        return XML_STATUS_ERROR;\n      }\n      // Since we know that the buffer was empty and XML_CONTEXT_BYTES is 0, we\n      // don't have any data to preserve, and can copy straight into the start\n      // of the buffer rather than the GetBuffer return pointer (which may be\n      // pointing further into the allocated buffer).\n      memcpy(parser->m_buffer, end, nLeftOver);\n    }\n    parser->m_bufferPtr = parser->m_buffer;\n    parser->m_bufferEnd = parser->m_buffer + nLeftOver;\n    parser->m_positionPtr = parser->m_bufferPtr;\n    parser->m_parseEndPtr = parser->m_bufferEnd;\n    parser->m_eventPtr = parser->m_bufferPtr;\n    parser->m_eventEndPtr = parser->m_bufferPtr;\n    return result;\n  }\n#endif /* XML_CONTEXT_BYTES == 0 */\n  void *buff = XML_GetBuffer(parser, len);\n  if (buff == NULL)\n    return XML_STATUS_ERROR;\n  if (len > 0) {\n    assert(s != NULL); // make sure s==NULL && len!=0 was rejected above\n    memcpy(buff, s, len);\n  }\n  return XML_ParseBuffer(parser, len, isFinal);\n}\n\nenum XML_Status XMLCALL\nXML_ParseBuffer(XML_Parser parser, int len, int isFinal) {\n  const char *start;\n  enum XML_Status result = XML_STATUS_OK;\n\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n\n  if (len < 0) {\n    parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;\n    return XML_STATUS_ERROR;\n  }\n\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return XML_STATUS_ERROR;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_INITIALIZED:\n    /* Has someone called XML_GetBuffer successfully before? */\n    if (! parser->m_bufferPtr) {\n      parser->m_errorCode = XML_ERROR_NO_BUFFER;\n      return XML_STATUS_ERROR;\n    }\n\n    if (parser->m_parentParser == NULL && ! startParsing(parser)) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return XML_STATUS_ERROR;\n    }\n    /* fall through */\n  default:\n    parser->m_parsingStatus.parsing = XML_PARSING;\n  }\n\n  start = parser->m_bufferPtr;\n  parser->m_positionPtr = start;\n  parser->m_bufferEnd += len;\n  parser->m_parseEndPtr = parser->m_bufferEnd;\n  parser->m_parseEndByteIndex += len;\n  parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;\n\n  parser->m_errorCode = callProcessor(parser, start, parser->m_parseEndPtr,\n                                      &parser->m_bufferPtr);\n\n  if (parser->m_errorCode != XML_ERROR_NONE) {\n    parser->m_eventEndPtr = parser->m_eventPtr;\n    parser->m_processor = errorProcessor;\n    return XML_STATUS_ERROR;\n  } else {\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      result = XML_STATUS_SUSPENDED;\n      break;\n    case XML_INITIALIZED:\n    case XML_PARSING:\n      if (isFinal) {\n        parser->m_parsingStatus.parsing = XML_FINISHED;\n        return result;\n      }\n    default:; /* should not happen */\n    }\n  }\n\n  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                    parser->m_bufferPtr, &parser->m_position);\n  parser->m_positionPtr = parser->m_bufferPtr;\n  return result;\n}\n\nvoid *XMLCALL\nXML_GetBuffer(XML_Parser parser, int len) {\n  if (parser == NULL)\n    return NULL;\n  if (len < 0) {\n    parser->m_errorCode = XML_ERROR_NO_MEMORY;\n    return NULL;\n  }\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return NULL;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return NULL;\n  default:;\n  }\n\n  // whether or not the request succeeds, `len` seems to be the app's preferred\n  // buffer fill size; remember it.\n  parser->m_lastBufferRequestSize = len;\n  if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)\n      || parser->m_buffer == NULL) {\n#if XML_CONTEXT_BYTES > 0\n    int keep;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    /* Do not invoke signed arithmetic overflow: */\n    int neededSize = (int)((unsigned)len\n                           + (unsigned)EXPAT_SAFE_PTR_DIFF(\n                               parser->m_bufferEnd, parser->m_bufferPtr));\n    if (neededSize < 0) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return NULL;\n    }\n#if XML_CONTEXT_BYTES > 0\n    keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);\n    if (keep > XML_CONTEXT_BYTES)\n      keep = XML_CONTEXT_BYTES;\n    /* Detect and prevent integer overflow */\n    if (keep > INT_MAX - neededSize) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return NULL;\n    }\n    neededSize += keep;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    if (parser->m_buffer && parser->m_bufferPtr\n        && neededSize\n               <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {\n#if XML_CONTEXT_BYTES > 0\n      if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {\n        int offset\n            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)\n              - keep;\n        /* The buffer pointers cannot be NULL here; we have at least some bytes\n         * in the buffer */\n        memmove(parser->m_buffer, &parser->m_buffer[offset],\n                parser->m_bufferEnd - parser->m_bufferPtr + keep);\n        parser->m_bufferEnd -= offset;\n        parser->m_bufferPtr -= offset;\n      }\n#else\n      memmove(parser->m_buffer, parser->m_bufferPtr,\n              EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));\n      parser->m_bufferEnd\n          = parser->m_buffer\n            + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);\n      parser->m_bufferPtr = parser->m_buffer;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    } else {\n      char *newBuf;\n      int bufferSize\n          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer);\n      if (bufferSize == 0)\n        bufferSize = INIT_BUFFER_SIZE;\n      do {\n        /* Do not invoke signed arithmetic overflow: */\n        bufferSize = (int)(2U * (unsigned)bufferSize);\n      } while (bufferSize < neededSize && bufferSize > 0);\n      if (bufferSize <= 0) {\n        parser->m_errorCode = XML_ERROR_NO_MEMORY;\n        return NULL;\n      }\n      // NOTE: We are avoiding MALLOC(..) here to leave limiting\n      //       the input size to the application using Expat.\n      newBuf = parser->m_mem.malloc_fcn(bufferSize);\n      if (newBuf == NULL) {\n        parser->m_errorCode = XML_ERROR_NO_MEMORY;\n        return NULL;\n      }\n      parser->m_bufferLim = newBuf + bufferSize;\n#if XML_CONTEXT_BYTES > 0\n      if (parser->m_bufferPtr) {\n        memcpy(newBuf, &parser->m_bufferPtr[-keep],\n               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)\n                   + keep);\n        // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n        //       is not being allocated with MALLOC(..) but with plain\n        //       .malloc_fcn(..).\n        parser->m_mem.free_fcn(parser->m_buffer);\n        parser->m_buffer = newBuf;\n        parser->m_bufferEnd\n            = parser->m_buffer\n              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)\n              + keep;\n        parser->m_bufferPtr = parser->m_buffer + keep;\n      } else {\n        /* This must be a brand new buffer with no data in it yet */\n        parser->m_bufferEnd = newBuf;\n        parser->m_bufferPtr = parser->m_buffer = newBuf;\n      }\n#else\n      if (parser->m_bufferPtr) {\n        memcpy(newBuf, parser->m_bufferPtr,\n               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));\n        // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n        //       is not being allocated with MALLOC(..) but with plain\n        //       .malloc_fcn(..).\n        parser->m_mem.free_fcn(parser->m_buffer);\n        parser->m_bufferEnd\n            = newBuf\n              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);\n      } else {\n        /* This must be a brand new buffer with no data in it yet */\n        parser->m_bufferEnd = newBuf;\n      }\n      parser->m_bufferPtr = parser->m_buffer = newBuf;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    }\n    parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n    parser->m_positionPtr = NULL;\n  }\n  return parser->m_bufferEnd;\n}\n\nstatic void\ntriggerReenter(XML_Parser parser) {\n  parser->m_reenter = XML_TRUE;\n}\n\nenum XML_Status XMLCALL\nXML_StopParser(XML_Parser parser, XML_Bool resumable) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_INITIALIZED:\n    parser->m_errorCode = XML_ERROR_NOT_STARTED;\n    return XML_STATUS_ERROR;\n  case XML_SUSPENDED:\n    if (resumable) {\n      parser->m_errorCode = XML_ERROR_SUSPENDED;\n      return XML_STATUS_ERROR;\n    }\n    parser->m_parsingStatus.parsing = XML_FINISHED;\n    break;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_PARSING:\n    if (resumable) {\n#ifdef XML_DTD\n      if (parser->m_isParamEntity) {\n        parser->m_errorCode = XML_ERROR_SUSPEND_PE;\n        return XML_STATUS_ERROR;\n      }\n#endif\n      parser->m_parsingStatus.parsing = XML_SUSPENDED;\n    } else\n      parser->m_parsingStatus.parsing = XML_FINISHED;\n    break;\n  default:\n    assert(0);\n  }\n  return XML_STATUS_OK;\n}\n\nenum XML_Status XMLCALL\nXML_ResumeParser(XML_Parser parser) {\n  enum XML_Status result = XML_STATUS_OK;\n\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {\n    parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;\n    return XML_STATUS_ERROR;\n  }\n  parser->m_parsingStatus.parsing = XML_PARSING;\n\n  parser->m_errorCode = callProcessor(\n      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);\n\n  if (parser->m_errorCode != XML_ERROR_NONE) {\n    parser->m_eventEndPtr = parser->m_eventPtr;\n    parser->m_processor = errorProcessor;\n    return XML_STATUS_ERROR;\n  } else {\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      result = XML_STATUS_SUSPENDED;\n      break;\n    case XML_INITIALIZED:\n    case XML_PARSING:\n      if (parser->m_parsingStatus.finalBuffer) {\n        parser->m_parsingStatus.parsing = XML_FINISHED;\n        return result;\n      }\n    default:;\n    }\n  }\n\n  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                    parser->m_bufferPtr, &parser->m_position);\n  parser->m_positionPtr = parser->m_bufferPtr;\n  return result;\n}\n\nvoid XMLCALL\nXML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {\n  if (parser == NULL)\n    return;\n  assert(status != NULL);\n  *status = parser->m_parsingStatus;\n}\n\nenum XML_Error XMLCALL\nXML_GetErrorCode(XML_Parser parser) {\n  if (parser == NULL)\n    return XML_ERROR_INVALID_ARGUMENT;\n  return parser->m_errorCode;\n}\n\nXML_Index XMLCALL\nXML_GetCurrentByteIndex(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  if (parser->m_eventPtr)\n    return (XML_Index)(parser->m_parseEndByteIndex\n                       - (parser->m_parseEndPtr - parser->m_eventPtr));\n  return -1;\n}\n\nint XMLCALL\nXML_GetCurrentByteCount(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventEndPtr && parser->m_eventPtr)\n    return (int)(parser->m_eventEndPtr - parser->m_eventPtr);\n  return 0;\n}\n\nconst char *XMLCALL\nXML_GetInputContext(XML_Parser parser, int *offset, int *size) {\n#if XML_CONTEXT_BYTES > 0\n  if (parser == NULL)\n    return NULL;\n  if (parser->m_eventPtr && parser->m_buffer) {\n    if (offset != NULL)\n      *offset = (int)(parser->m_eventPtr - parser->m_buffer);\n    if (size != NULL)\n      *size = (int)(parser->m_bufferEnd - parser->m_buffer);\n    return parser->m_buffer;\n  }\n#else\n  (void)parser;\n  (void)offset;\n  (void)size;\n#endif /* XML_CONTEXT_BYTES > 0 */\n  return (const char *)0;\n}\n\nXML_Size XMLCALL\nXML_GetCurrentLineNumber(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                      parser->m_eventPtr, &parser->m_position);\n    parser->m_positionPtr = parser->m_eventPtr;\n  }\n  return parser->m_position.lineNumber + 1;\n}\n\nXML_Size XMLCALL\nXML_GetCurrentColumnNumber(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                      parser->m_eventPtr, &parser->m_position);\n    parser->m_positionPtr = parser->m_eventPtr;\n  }\n  return parser->m_position.columnNumber;\n}\n\nvoid XMLCALL\nXML_FreeContentModel(XML_Parser parser, XML_Content *model) {\n  if (parser == NULL)\n    return;\n\n  // NOTE: We are avoiding FREE(..) here because the content model\n  //       has been created using plain .malloc_fcn(..) rather than MALLOC(..).\n  parser->m_mem.free_fcn(model);\n}\n\nvoid *XMLCALL\nXML_MemMalloc(XML_Parser parser, size_t size) {\n  if (parser == NULL)\n    return NULL;\n\n  // NOTE: We are avoiding MALLOC(..) here to not include\n  //       user allocations with allocation tracking and limiting.\n  return parser->m_mem.malloc_fcn(size);\n}\n\nvoid *XMLCALL\nXML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {\n  if (parser == NULL)\n    return NULL;\n\n  // NOTE: We are avoiding REALLOC(..) here to not include\n  //       user allocations with allocation tracking and limiting.\n  return parser->m_mem.realloc_fcn(ptr, size);\n}\n\nvoid XMLCALL\nXML_MemFree(XML_Parser parser, void *ptr) {\n  if (parser == NULL)\n    return;\n\n  // NOTE: We are avoiding FREE(..) here because XML_MemMalloc and\n  //       XML_MemRealloc are not using MALLOC(..) and REALLOC(..)\n  //       but plain .malloc_fcn(..) and .realloc_fcn(..), internally.\n  parser->m_mem.free_fcn(ptr);\n}\n\nvoid XMLCALL\nXML_DefaultCurrent(XML_Parser parser) {\n  if (parser == NULL)\n    return;\n  if (parser->m_defaultHandler) {\n    if (parser->m_openInternalEntities)\n      reportDefault(parser, parser->m_internalEncoding,\n                    parser->m_openInternalEntities->internalEventPtr,\n                    parser->m_openInternalEntities->internalEventEndPtr);\n    else\n      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,\n                    parser->m_eventEndPtr);\n  }\n}\n\nconst XML_LChar *XMLCALL\nXML_ErrorString(enum XML_Error code) {\n  switch (code) {\n  case XML_ERROR_NONE:\n    return NULL;\n  case XML_ERROR_NO_MEMORY:\n    return XML_L(\"out of memory\");\n  case XML_ERROR_SYNTAX:\n    return XML_L(\"syntax error\");\n  case XML_ERROR_NO_ELEMENTS:\n    return XML_L(\"no element found\");\n  case XML_ERROR_INVALID_TOKEN:\n    return XML_L(\"not well-formed (invalid token)\");\n  case XML_ERROR_UNCLOSED_TOKEN:\n    return XML_L(\"unclosed token\");\n  case XML_ERROR_PARTIAL_CHAR:\n    return XML_L(\"partial character\");\n  case XML_ERROR_TAG_MISMATCH:\n    return XML_L(\"mismatched tag\");\n  case XML_ERROR_DUPLICATE_ATTRIBUTE:\n    return XML_L(\"duplicate attribute\");\n  case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:\n    return XML_L(\"junk after document element\");\n  case XML_ERROR_PARAM_ENTITY_REF:\n    return XML_L(\"illegal parameter entity reference\");\n  case XML_ERROR_UNDEFINED_ENTITY:\n    return XML_L(\"undefined entity\");\n  case XML_ERROR_RECURSIVE_ENTITY_REF:\n    return XML_L(\"recursive entity reference\");\n  case XML_ERROR_ASYNC_ENTITY:\n    return XML_L(\"asynchronous entity\");\n  case XML_ERROR_BAD_CHAR_REF:\n    return XML_L(\"reference to invalid character number\");\n  case XML_ERROR_BINARY_ENTITY_REF:\n    return XML_L(\"reference to binary entity\");\n  case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:\n    return XML_L(\"reference to external entity in attribute\");\n  case XML_ERROR_MISPLACED_XML_PI:\n    return XML_L(\"XML or text declaration not at start of entity\");\n  case XML_ERROR_UNKNOWN_ENCODING:\n    return XML_L(\"unknown encoding\");\n  case XML_ERROR_INCORRECT_ENCODING:\n    return XML_L(\"encoding specified in XML declaration is incorrect\");\n  case XML_ERROR_UNCLOSED_CDATA_SECTION:\n    return XML_L(\"unclosed CDATA section\");\n  case XML_ERROR_EXTERNAL_ENTITY_HANDLING:\n    return XML_L(\"error in processing external entity reference\");\n  case XML_ERROR_NOT_STANDALONE:\n    return XML_L(\"document is not standalone\");\n  case XML_ERROR_UNEXPECTED_STATE:\n    return XML_L(\"unexpected parser state - please send a bug report\");\n  case XML_ERROR_ENTITY_DECLARED_IN_PE:\n    return XML_L(\"entity declared in parameter entity\");\n  case XML_ERROR_FEATURE_REQUIRES_XML_DTD:\n    return XML_L(\"requested feature requires XML_DTD support in Expat\");\n  case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:\n    return XML_L(\"cannot change setting once parsing has begun\");\n  /* Added in 1.95.7. */\n  case XML_ERROR_UNBOUND_PREFIX:\n    return XML_L(\"unbound prefix\");\n  /* Added in 1.95.8. */\n  case XML_ERROR_UNDECLARING_PREFIX:\n    return XML_L(\"must not undeclare prefix\");\n  case XML_ERROR_INCOMPLETE_PE:\n    return XML_L(\"incomplete markup in parameter entity\");\n  case XML_ERROR_XML_DECL:\n    return XML_L(\"XML declaration not well-formed\");\n  case XML_ERROR_TEXT_DECL:\n    return XML_L(\"text declaration not well-formed\");\n  case XML_ERROR_PUBLICID:\n    return XML_L(\"illegal character(s) in public id\");\n  case XML_ERROR_SUSPENDED:\n    return XML_L(\"parser suspended\");\n  case XML_ERROR_NOT_SUSPENDED:\n    return XML_L(\"parser not suspended\");\n  case XML_ERROR_ABORTED:\n    return XML_L(\"parsing aborted\");\n  case XML_ERROR_FINISHED:\n    return XML_L(\"parsing finished\");\n  case XML_ERROR_SUSPEND_PE:\n    return XML_L(\"cannot suspend in external parameter entity\");\n  /* Added in 2.0.0. */\n  case XML_ERROR_RESERVED_PREFIX_XML:\n    return XML_L(\n        \"reserved prefix (xml) must not be undeclared or bound to another namespace name\");\n  case XML_ERROR_RESERVED_PREFIX_XMLNS:\n    return XML_L(\"reserved prefix (xmlns) must not be declared or undeclared\");\n  case XML_ERROR_RESERVED_NAMESPACE_URI:\n    return XML_L(\n        \"prefix must not be bound to one of the reserved namespace names\");\n  /* Added in 2.2.5. */\n  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */\n    return XML_L(\"invalid argument\");\n    /* Added in 2.3.0. */\n  case XML_ERROR_NO_BUFFER:\n    return XML_L(\n        \"a successful prior call to function XML_GetBuffer is required\");\n  /* Added in 2.4.0. */\n  case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:\n    return XML_L(\n        \"limit on input amplification factor (from DTD and entities) breached\");\n  /* Added in 2.6.4. */\n  case XML_ERROR_NOT_STARTED:\n    return XML_L(\"parser not started\");\n  }\n  return NULL;\n}\n\nconst XML_LChar *XMLCALL\nXML_ExpatVersion(void) {\n  /* V1 is used to string-ize the version number. However, it would\n     string-ize the actual version macro *names* unless we get them\n     substituted before being passed to V1. CPP is defined to expand\n     a macro, then rescan for more expansions. Thus, we use V2 to expand\n     the version macros, then CPP will expand the resulting V1() macro\n     with the correct numerals. */\n  /* ### I'm assuming cpp is portable in this respect... */\n\n#define V1(a, b, c) XML_L(#a) XML_L(\".\") XML_L(#b) XML_L(\".\") XML_L(#c)\n#define V2(a, b, c) XML_L(\"expat_\") V1(a, b, c)\n\n  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);\n\n#undef V1\n#undef V2\n}\n\nXML_Expat_Version XMLCALL\nXML_ExpatVersionInfo(void) {\n  XML_Expat_Version version;\n\n  version.major = XML_MAJOR_VERSION;\n  version.minor = XML_MINOR_VERSION;\n  version.micro = XML_MICRO_VERSION;\n\n  return version;\n}\n\nconst XML_Feature *XMLCALL\nXML_GetFeatureList(void) {\n  static const XML_Feature features[] = {\n      {XML_FEATURE_SIZEOF_XML_CHAR, XML_L(\"sizeof(XML_Char)\"),\n       sizeof(XML_Char)},\n      {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L(\"sizeof(XML_LChar)\"),\n       sizeof(XML_LChar)},\n#ifdef XML_UNICODE\n      {XML_FEATURE_UNICODE, XML_L(\"XML_UNICODE\"), 0},\n#endif\n#ifdef XML_UNICODE_WCHAR_T\n      {XML_FEATURE_UNICODE_WCHAR_T, XML_L(\"XML_UNICODE_WCHAR_T\"), 0},\n#endif\n#ifdef XML_DTD\n      {XML_FEATURE_DTD, XML_L(\"XML_DTD\"), 0},\n#endif\n#if XML_CONTEXT_BYTES > 0\n      {XML_FEATURE_CONTEXT_BYTES, XML_L(\"XML_CONTEXT_BYTES\"),\n       XML_CONTEXT_BYTES},\n#endif\n#ifdef XML_MIN_SIZE\n      {XML_FEATURE_MIN_SIZE, XML_L(\"XML_MIN_SIZE\"), 0},\n#endif\n#ifdef XML_NS\n      {XML_FEATURE_NS, XML_L(\"XML_NS\"), 0},\n#endif\n#ifdef XML_LARGE_SIZE\n      {XML_FEATURE_LARGE_SIZE, XML_L(\"XML_LARGE_SIZE\"), 0},\n#endif\n#ifdef XML_ATTR_INFO\n      {XML_FEATURE_ATTR_INFO, XML_L(\"XML_ATTR_INFO\"), 0},\n#endif\n#if XML_GE == 1\n      /* Added in Expat 2.4.0 for XML_DTD defined and\n       * added in Expat 2.6.0 for XML_GE == 1. */\n      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,\n       XML_L(\"XML_BLAP_MAX_AMP\"),\n       (long int)\n           EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},\n      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,\n       XML_L(\"XML_BLAP_ACT_THRES\"),\n       EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},\n      /* Added in Expat 2.6.0. */\n      {XML_FEATURE_GE, XML_L(\"XML_GE\"), 0},\n      /* Added in Expat 2.7.2. */\n      {XML_FEATURE_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT,\n       XML_L(\"XML_AT_MAX_AMP\"),\n       (long int)EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT},\n      {XML_FEATURE_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT,\n       XML_L(\"XML_AT_ACT_THRES\"),\n       (long int)EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT},\n#endif\n      {XML_FEATURE_END, NULL, 0}};\n\n  return features;\n}\n\n#if XML_GE == 1\nXML_Bool XMLCALL\nXML_SetBillionLaughsAttackProtectionMaximumAmplification(\n    XML_Parser parser, float maximumAmplificationFactor) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)\n      || isnan(maximumAmplificationFactor)\n      || (maximumAmplificationFactor < 1.0f)) {\n    return XML_FALSE;\n  }\n  parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetBillionLaughsAttackProtectionActivationThreshold(\n    XML_Parser parser, unsigned long long activationThresholdBytes) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)) {\n    return XML_FALSE;\n  }\n  parser->m_accounting.activationThresholdBytes = activationThresholdBytes;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetAllocTrackerMaximumAmplification(XML_Parser parser,\n                                        float maximumAmplificationFactor) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)\n      || isnan(maximumAmplificationFactor)\n      || (maximumAmplificationFactor < 1.0f)) {\n    return XML_FALSE;\n  }\n  parser->m_alloc_tracker.maximumAmplificationFactor\n      = maximumAmplificationFactor;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetAllocTrackerActivationThreshold(\n    XML_Parser parser, unsigned long long activationThresholdBytes) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)) {\n    return XML_FALSE;\n  }\n  parser->m_alloc_tracker.activationThresholdBytes = activationThresholdBytes;\n  return XML_TRUE;\n}\n#endif /* XML_GE == 1 */\n\nXML_Bool XMLCALL\nXML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled) {\n  if (parser != NULL && (enabled == XML_TRUE || enabled == XML_FALSE)) {\n    parser->m_reparseDeferralEnabled = enabled;\n    return XML_TRUE;\n  }\n  return XML_FALSE;\n}\n\n/* Initially tag->rawName always points into the parse buffer;\n   for those TAG instances opened while the current parse buffer was\n   processed, and not yet closed, we need to store tag->rawName in a more\n   permanent location, since the parse buffer is about to be discarded.\n*/\nstatic XML_Bool\nstoreRawNames(XML_Parser parser) {\n  TAG *tag = parser->m_tagStack;\n  while (tag) {\n    size_t bufSize;\n    size_t nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);\n    size_t rawNameLen;\n    char *rawNameBuf = tag->buf.raw + nameLen;\n    /* Stop if already stored.  Since m_tagStack is a stack, we can stop\n       at the first entry that has already been copied; everything\n       below it in the stack is already been accounted for in a\n       previous call to this function.\n    */\n    if (tag->rawName == rawNameBuf)\n      break;\n    /* For reuse purposes we need to ensure that the\n       size of tag->buf is a multiple of sizeof(XML_Char).\n    */\n    rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char));\n    /* Detect and prevent integer overflow. */\n    if (rawNameLen > (size_t)INT_MAX - nameLen)\n      return XML_FALSE;\n    bufSize = nameLen + rawNameLen;\n    if (bufSize > (size_t)(tag->bufEnd - tag->buf.raw)) {\n      char *temp = REALLOC(parser, tag->buf.raw, bufSize);\n      if (temp == NULL)\n        return XML_FALSE;\n      /* if tag->name.str points to tag->buf.str (only when namespace\n         processing is off) then we have to update it\n      */\n      if (tag->name.str == tag->buf.str)\n        tag->name.str = (XML_Char *)temp;\n      /* if tag->name.localPart is set (when namespace processing is on)\n         then update it as well, since it will always point into tag->buf\n      */\n      if (tag->name.localPart)\n        tag->name.localPart\n            = (XML_Char *)temp + (tag->name.localPart - tag->buf.str);\n      tag->buf.raw = temp;\n      tag->bufEnd = temp + bufSize;\n      rawNameBuf = temp + nameLen;\n    }\n    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);\n    tag->rawName = rawNameBuf;\n    tag = tag->parent;\n  }\n  return XML_TRUE;\n}\n\nstatic enum XML_Error PTRCALL\ncontentProcessor(XML_Parser parser, const char *start, const char *end,\n                 const char **endPtr) {\n  enum XML_Error result = doContent(\n      parser, parser->m_parentParser ? 1 : 0, parser->m_encoding, start, end,\n      endPtr, (XML_Bool)! parser->m_parsingStatus.finalBuffer,\n      XML_ACCOUNT_DIRECT);\n  if (result == XML_ERROR_NONE) {\n    if (! storeRawNames(parser))\n      return XML_ERROR_NO_MEMORY;\n  }\n  return result;\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor(XML_Parser parser, const char *start,\n                            const char *end, const char **endPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n  parser->m_processor = externalEntityInitProcessor2;\n  return externalEntityInitProcessor2(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor2(XML_Parser parser, const char *start,\n                             const char *end, const char **endPtr) {\n  const char *next = start; /* XmlContentTok doesn't always set the last arg */\n  int tok = XmlContentTok(parser->m_encoding, start, end, &next);\n  switch (tok) {\n  case XML_TOK_BOM:\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif /* XML_GE == 1 */\n\n    /* If we are at the end of the buffer, this would cause the next stage,\n       i.e. externalEntityInitProcessor3, to pass control directly to\n       doContent (by detecting XML_TOK_NONE) without processing any xml text\n       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.\n    */\n    if (next == end && ! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = next;\n      return XML_ERROR_NONE;\n    }\n    start = next;\n    break;\n  case XML_TOK_PARTIAL:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    parser->m_eventPtr = start;\n    return XML_ERROR_UNCLOSED_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    parser->m_eventPtr = start;\n    return XML_ERROR_PARTIAL_CHAR;\n  }\n  parser->m_processor = externalEntityInitProcessor3;\n  return externalEntityInitProcessor3(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor3(XML_Parser parser, const char *start,\n                             const char *end, const char **endPtr) {\n  int tok;\n  const char *next = start; /* XmlContentTok doesn't always set the last arg */\n  parser->m_eventPtr = start;\n  tok = XmlContentTok(parser->m_encoding, start, end, &next);\n  /* Note: These bytes are accounted later in:\n           - processXmlDecl\n           - externalEntityContentProcessor\n  */\n  parser->m_eventEndPtr = next;\n\n  switch (tok) {\n  case XML_TOK_XML_DECL: {\n    enum XML_Error result;\n    result = processXmlDecl(parser, 1, start, next);\n    if (result != XML_ERROR_NONE)\n      return result;\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *endPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n      /* Fall through */\n    default:\n      start = next;\n    }\n  } break;\n  case XML_TOK_PARTIAL:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_UNCLOSED_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_PARTIAL_CHAR;\n  }\n  parser->m_processor = externalEntityContentProcessor;\n  parser->m_tagLevel = 1;\n  return externalEntityContentProcessor(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityContentProcessor(XML_Parser parser, const char *start,\n                               const char *end, const char **endPtr) {\n  enum XML_Error result\n      = doContent(parser, 1, parser->m_encoding, start, end, endPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer,\n                  XML_ACCOUNT_ENTITY_EXPANSION);\n  if (result == XML_ERROR_NONE) {\n    if (! storeRawNames(parser))\n      return XML_ERROR_NO_MEMORY;\n  }\n  return result;\n}\n\nstatic enum XML_Error\ndoContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,\n          const char *s, const char *end, const char **nextPtr,\n          XML_Bool haveMore, enum XML_Account account) {\n  /* save one level of indirection */\n  DTD *const dtd = parser->m_dtd;\n\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n  *eventPP = s;\n\n  for (;;) {\n    const char *next = s; /* XmlContentTok doesn't always set the last arg */\n    int tok = XmlContentTok(enc, s, end, &next);\n#if XML_GE == 1\n    const char *accountAfter\n        = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR))\n              ? (haveMore ? s /* i.e. 0 bytes */ : end)\n              : next;\n    if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,\n                                  account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    *eventEndPP = next;\n    switch (tok) {\n    case XML_TOK_TRAILING_CR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      *eventEndPP = end;\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, end);\n      /* We are at the end of the final buffer, should we check for\n         XML_SUSPENDED, XML_FINISHED?\n      */\n      if (startTagLevel == 0)\n        return XML_ERROR_NO_ELEMENTS;\n      if (parser->m_tagLevel != startTagLevel)\n        return XML_ERROR_ASYNC_ENTITY;\n      *nextPtr = end;\n      return XML_ERROR_NONE;\n    case XML_TOK_NONE:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      if (startTagLevel > 0) {\n        if (parser->m_tagLevel != startTagLevel)\n          return XML_ERROR_ASYNC_ENTITY;\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_NO_ELEMENTS;\n    case XML_TOK_INVALID:\n      *eventPP = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_ENTITY_REF: {\n      const XML_Char *name;\n      ENTITY *entity;\n      XML_Char ch = (XML_Char)XmlPredefinedEntityName(\n          enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);\n      if (ch) {\n#if XML_GE == 1\n        /* NOTE: We are replacing 4-6 characters original input for 1 character\n         *       so there is no amplification and hence recording without\n         *       protection. */\n        accountingDiffTolerated(parser, tok, (char *)&ch,\n                                ((char *)&ch) + sizeof(XML_Char), __LINE__,\n                                XML_ACCOUNT_ENTITY_EXPANSION);\n#endif /* XML_GE == 1 */\n        if (parser->m_characterDataHandler)\n          parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);\n        else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        break;\n      }\n      name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                             next - enc->minBytesPerChar);\n      if (! name)\n        return XML_ERROR_NO_MEMORY;\n      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);\n      poolDiscard(&dtd->pool);\n      /* First, determine if a check for an existing declaration is needed;\n         if yes, check that the entity exists, and that it is internal,\n         otherwise call the skipped entity or default handler.\n      */\n      if (! dtd->hasParamEntityRefs || dtd->standalone) {\n        if (! entity)\n          return XML_ERROR_UNDEFINED_ENTITY;\n        else if (! entity->is_internal)\n          return XML_ERROR_ENTITY_DECLARED_IN_PE;\n      } else if (! entity) {\n        if (parser->m_skippedEntityHandler)\n          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n        else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        break;\n      }\n      if (entity->open)\n        return XML_ERROR_RECURSIVE_ENTITY_REF;\n      if (entity->notation)\n        return XML_ERROR_BINARY_ENTITY_REF;\n      if (entity->textPtr) {\n        enum XML_Error result;\n        if (! parser->m_defaultExpandInternalEntities) {\n          if (parser->m_skippedEntityHandler)\n            parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,\n                                           0);\n          else if (parser->m_defaultHandler)\n            reportDefault(parser, enc, s, next);\n          break;\n        }\n        result = processEntity(parser, entity, XML_FALSE, ENTITY_INTERNAL);\n        if (result != XML_ERROR_NONE)\n          return result;\n      } else if (parser->m_externalEntityRefHandler) {\n        const XML_Char *context;\n        entity->open = XML_TRUE;\n        context = getContext(parser);\n        entity->open = XML_FALSE;\n        if (! context)\n          return XML_ERROR_NO_MEMORY;\n        if (! parser->m_externalEntityRefHandler(\n                parser->m_externalEntityRefHandlerArg, context, entity->base,\n                entity->systemId, entity->publicId))\n          return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n        poolDiscard(&parser->m_tempPool);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    }\n    case XML_TOK_START_TAG_NO_ATTS:\n      /* fall through */\n    case XML_TOK_START_TAG_WITH_ATTS: {\n      TAG *tag;\n      enum XML_Error result;\n      XML_Char *toPtr;\n      if (parser->m_freeTagList) {\n        tag = parser->m_freeTagList;\n        parser->m_freeTagList = parser->m_freeTagList->parent;\n      } else {\n        tag = MALLOC(parser, sizeof(TAG));\n        if (! tag)\n          return XML_ERROR_NO_MEMORY;\n        tag->buf.raw = MALLOC(parser, INIT_TAG_BUF_SIZE);\n        if (! tag->buf.raw) {\n          FREE(parser, tag);\n          return XML_ERROR_NO_MEMORY;\n        }\n        tag->bufEnd = tag->buf.raw + INIT_TAG_BUF_SIZE;\n      }\n      tag->bindings = NULL;\n      tag->parent = parser->m_tagStack;\n      parser->m_tagStack = tag;\n      tag->name.localPart = NULL;\n      tag->name.prefix = NULL;\n      tag->rawName = s + enc->minBytesPerChar;\n      tag->rawNameLength = XmlNameLength(enc, tag->rawName);\n      ++parser->m_tagLevel;\n      {\n        const char *rawNameEnd = tag->rawName + tag->rawNameLength;\n        const char *fromPtr = tag->rawName;\n        toPtr = tag->buf.str;\n        for (;;) {\n          int convLen;\n          const enum XML_Convert_Result convert_res\n              = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,\n                           (ICHAR *)tag->bufEnd - 1);\n          convLen = (int)(toPtr - tag->buf.str);\n          if ((fromPtr >= rawNameEnd)\n              || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {\n            tag->name.strLen = convLen;\n            break;\n          }\n          if (SIZE_MAX / 2 < (size_t)(tag->bufEnd - tag->buf.raw))\n            return XML_ERROR_NO_MEMORY;\n          const size_t bufSize = (size_t)(tag->bufEnd - tag->buf.raw) * 2;\n          {\n            char *temp = REALLOC(parser, tag->buf.raw, bufSize);\n            if (temp == NULL)\n              return XML_ERROR_NO_MEMORY;\n            tag->buf.raw = temp;\n            tag->bufEnd = temp + bufSize;\n            toPtr = (XML_Char *)temp + convLen;\n          }\n        }\n      }\n      tag->name.str = tag->buf.str;\n      *toPtr = XML_T('\\0');\n      result\n          = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);\n      if (result)\n        return result;\n      if (parser->m_startElementHandler)\n        parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,\n                                      (const XML_Char **)parser->m_atts);\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      poolClear(&parser->m_tempPool);\n      break;\n    }\n    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:\n      /* fall through */\n    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {\n      const char *rawName = s + enc->minBytesPerChar;\n      enum XML_Error result;\n      BINDING *bindings = NULL;\n      XML_Bool noElmHandlers = XML_TRUE;\n      TAG_NAME name;\n      name.str = poolStoreString(&parser->m_tempPool, enc, rawName,\n                                 rawName + XmlNameLength(enc, rawName));\n      if (! name.str)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_tempPool);\n      result = storeAtts(parser, enc, s, &name, &bindings,\n                         XML_ACCOUNT_NONE /* token spans whole start tag */);\n      if (result != XML_ERROR_NONE) {\n        freeBindings(parser, bindings);\n        return result;\n      }\n      poolFinish(&parser->m_tempPool);\n      if (parser->m_startElementHandler) {\n        parser->m_startElementHandler(parser->m_handlerArg, name.str,\n                                      (const XML_Char **)parser->m_atts);\n        noElmHandlers = XML_FALSE;\n      }\n      if (parser->m_endElementHandler) {\n        if (parser->m_startElementHandler)\n          *eventPP = *eventEndPP;\n        parser->m_endElementHandler(parser->m_handlerArg, name.str);\n        noElmHandlers = XML_FALSE;\n      }\n      if (noElmHandlers && parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      poolClear(&parser->m_tempPool);\n      freeBindings(parser, bindings);\n    }\n      if ((parser->m_tagLevel == 0)\n          && (parser->m_parsingStatus.parsing != XML_FINISHED)) {\n        if (parser->m_parsingStatus.parsing == XML_SUSPENDED\n            || (parser->m_parsingStatus.parsing == XML_PARSING\n                && parser->m_reenter))\n          parser->m_processor = epilogProcessor;\n        else\n          return epilogProcessor(parser, next, end, nextPtr);\n      }\n      break;\n    case XML_TOK_END_TAG:\n      if (parser->m_tagLevel == startTagLevel)\n        return XML_ERROR_ASYNC_ENTITY;\n      else {\n        int len;\n        const char *rawName;\n        TAG *tag = parser->m_tagStack;\n        rawName = s + enc->minBytesPerChar * 2;\n        len = XmlNameLength(enc, rawName);\n        if (len != tag->rawNameLength\n            || memcmp(tag->rawName, rawName, len) != 0) {\n          *eventPP = rawName;\n          return XML_ERROR_TAG_MISMATCH;\n        }\n        parser->m_tagStack = tag->parent;\n        tag->parent = parser->m_freeTagList;\n        parser->m_freeTagList = tag;\n        --parser->m_tagLevel;\n        if (parser->m_endElementHandler) {\n          const XML_Char *localPart;\n          const XML_Char *prefix;\n          XML_Char *uri;\n          localPart = tag->name.localPart;\n          if (parser->m_ns && localPart) {\n            /* localPart and prefix may have been overwritten in\n               tag->name.str, since this points to the binding->uri\n               buffer which gets reused; so we have to add them again\n            */\n            uri = (XML_Char *)tag->name.str + tag->name.uriLen;\n            /* don't need to check for space - already done in storeAtts() */\n            while (*localPart)\n              *uri++ = *localPart++;\n            prefix = tag->name.prefix;\n            if (parser->m_ns_triplets && prefix) {\n              *uri++ = parser->m_namespaceSeparator;\n              while (*prefix)\n                *uri++ = *prefix++;\n            }\n            *uri = XML_T('\\0');\n          }\n          parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);\n        } else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        while (tag->bindings) {\n          BINDING *b = tag->bindings;\n          if (parser->m_endNamespaceDeclHandler)\n            parser->m_endNamespaceDeclHandler(parser->m_handlerArg,\n                                              b->prefix->name);\n          tag->bindings = tag->bindings->nextTagBinding;\n          b->nextTagBinding = parser->m_freeBindingList;\n          parser->m_freeBindingList = b;\n          b->prefix->binding = b->prevPrefixBinding;\n        }\n        if ((parser->m_tagLevel == 0)\n            && (parser->m_parsingStatus.parsing != XML_FINISHED)) {\n          if (parser->m_parsingStatus.parsing == XML_SUSPENDED\n              || (parser->m_parsingStatus.parsing == XML_PARSING\n                  && parser->m_reenter))\n            parser->m_processor = epilogProcessor;\n          else\n            return epilogProcessor(parser, next, end, nextPtr);\n        }\n      }\n      break;\n    case XML_TOK_CHAR_REF: {\n      int n = XmlCharRefNumber(enc, s);\n      if (n < 0)\n        return XML_ERROR_BAD_CHAR_REF;\n      if (parser->m_characterDataHandler) {\n        XML_Char buf[XML_ENCODE_MAX];\n        parser->m_characterDataHandler(parser->m_handlerArg, buf,\n                                       XmlEncode(n, (ICHAR *)buf));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_XML_DECL:\n      return XML_ERROR_MISPLACED_XML_PI;\n    case XML_TOK_DATA_NEWLINE:\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    case XML_TOK_CDATA_SECT_OPEN: {\n      enum XML_Error result;\n      if (parser->m_startCdataSectionHandler)\n        parser->m_startCdataSectionHandler(parser->m_handlerArg);\n      /* BEGIN disabled code */\n      /* Suppose you doing a transformation on a document that involves\n         changing only the character data.  You set up a defaultHandler\n         and a characterDataHandler.  The defaultHandler simply copies\n         characters through.  The characterDataHandler does the\n         transformation and writes the characters out escaping them as\n         necessary.  This case will fail to work if we leave out the\n         following two lines (because & and < inside CDATA sections will\n         be incorrectly escaped).\n\n         However, now we have a start/endCdataSectionHandler, so it seems\n         easier to let the user deal with this.\n      */\n      else if ((0) && parser->m_characterDataHandler)\n        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                                       0);\n      /* END disabled code */\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      result\n          = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);\n      if (result != XML_ERROR_NONE)\n        return result;\n      else if (! next) {\n        parser->m_processor = cdataSectionProcessor;\n        return result;\n      }\n    } break;\n    case XML_TOK_TRAILING_RSQB:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      if (parser->m_characterDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n          parser->m_characterDataHandler(\n              parser->m_handlerArg, parser->m_dataBuf,\n              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n        } else\n          parser->m_characterDataHandler(\n              parser->m_handlerArg, (const XML_Char *)s,\n              (int)((const XML_Char *)end - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, end);\n      /* We are at the end of the final buffer, should we check for\n         XML_SUSPENDED, XML_FINISHED?\n      */\n      if (startTagLevel == 0) {\n        *eventPP = end;\n        return XML_ERROR_NO_ELEMENTS;\n      }\n      if (parser->m_tagLevel != startTagLevel) {\n        *eventPP = end;\n        return XML_ERROR_ASYNC_ENTITY;\n      }\n      *nextPtr = end;\n      return XML_ERROR_NONE;\n    case XML_TOK_DATA_CHARS: {\n      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;\n      if (charDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          for (;;) {\n            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n            const enum XML_Convert_Result convert_res = XmlConvert(\n                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n            *eventEndPP = s;\n            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n            if ((convert_res == XML_CONVERT_COMPLETED)\n                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n              break;\n            *eventPP = s;\n          }\n        } else\n          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,\n                          (int)((const XML_Char *)next - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_PI:\n      if (! reportProcessingInstruction(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_COMMENT:\n      if (! reportComment(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    default:\n      /* All of the tokens produced by XmlContentTok() have their own\n       * explicit cases, so this default is not strictly necessary.\n       * However it is a useful safety net, so we retain the code and\n       * simply exclude it from the coverage tests.\n       *\n       * LCOV_EXCL_START\n       */\n      if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n      /* LCOV_EXCL_STOP */\n    }\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *eventPP = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      *eventPP = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        *nextPtr = next;\n        return XML_ERROR_NONE;\n      }\n      /* Fall through */\n    default:;\n      *eventPP = s = next;\n    }\n  }\n  /* not reached */\n}\n\n/* This function does not call free() on the allocated memory, merely\n * moving it to the parser's m_freeBindingList where it can be freed or\n * reused as appropriate.\n */\nstatic void\nfreeBindings(XML_Parser parser, BINDING *bindings) {\n  while (bindings) {\n    BINDING *b = bindings;\n\n    /* m_startNamespaceDeclHandler will have been called for this\n     * binding in addBindings(), so call the end handler now.\n     */\n    if (parser->m_endNamespaceDeclHandler)\n      parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);\n\n    bindings = bindings->nextTagBinding;\n    b->nextTagBinding = parser->m_freeBindingList;\n    parser->m_freeBindingList = b;\n    b->prefix->binding = b->prevPrefixBinding;\n  }\n}\n\n/* Precondition: all arguments must be non-NULL;\n   Purpose:\n   - normalize attributes\n   - check attributes for well-formedness\n   - generate namespace aware attribute names (URI, prefix)\n   - build list of attributes for startElementHandler\n   - default attributes\n   - process namespace declarations (check and report them)\n   - generate namespace aware element name (URI, prefix)\n*/\nstatic enum XML_Error\nstoreAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,\n          TAG_NAME *tagNamePtr, BINDING **bindingsPtr,\n          enum XML_Account account) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  ELEMENT_TYPE *elementType;\n  int nDefaultAtts;\n  const XML_Char **appAtts; /* the attribute list for the application */\n  int attIndex = 0;\n  int prefixLen;\n  int i;\n  int n;\n  XML_Char *uri;\n  int nPrefixes = 0;\n  BINDING *binding;\n  const XML_Char *localPart;\n\n  /* lookup the element type name */\n  elementType\n      = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);\n  if (! elementType) {\n    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);\n    if (! name)\n      return XML_ERROR_NO_MEMORY;\n    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,\n                                         sizeof(ELEMENT_TYPE));\n    if (! elementType)\n      return XML_ERROR_NO_MEMORY;\n    if (parser->m_ns && ! setElementTypePrefix(parser, elementType))\n      return XML_ERROR_NO_MEMORY;\n  }\n  nDefaultAtts = elementType->nDefaultAtts;\n\n  /* get the attributes from the tokenizer */\n  n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);\n\n  /* Detect and prevent integer overflow */\n  if (n > INT_MAX - nDefaultAtts) {\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  if (n + nDefaultAtts > parser->m_attsSize) {\n    int oldAttsSize = parser->m_attsSize;\n    ATTRIBUTE *temp;\n#ifdef XML_ATTR_INFO\n    XML_AttrInfo *temp2;\n#endif\n\n    /* Detect and prevent integer overflow */\n    if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)\n        || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {\n      return XML_ERROR_NO_MEMORY;\n    }\n\n    parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;\n\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)parser->m_attsSize > SIZE_MAX / sizeof(ATTRIBUTE)) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    temp = REALLOC(parser, parser->m_atts,\n                   parser->m_attsSize * sizeof(ATTRIBUTE));\n    if (temp == NULL) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_atts = temp;\n#ifdef XML_ATTR_INFO\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#  if UINT_MAX >= SIZE_MAX\n    if ((unsigned)parser->m_attsSize > SIZE_MAX / sizeof(XML_AttrInfo)) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n#  endif\n\n    temp2 = REALLOC(parser, parser->m_attInfo,\n                    parser->m_attsSize * sizeof(XML_AttrInfo));\n    if (temp2 == NULL) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_attInfo = temp2;\n#endif\n    if (n > oldAttsSize)\n      XmlGetAttributes(enc, attStr, n, parser->m_atts);\n  }\n\n  appAtts = (const XML_Char **)parser->m_atts;\n  for (i = 0; i < n; i++) {\n    ATTRIBUTE *currAtt = &parser->m_atts[i];\n#ifdef XML_ATTR_INFO\n    XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];\n#endif\n    /* add the name and value to the attribute list */\n    ATTRIBUTE_ID *attId\n        = getAttributeId(parser, enc, currAtt->name,\n                         currAtt->name + XmlNameLength(enc, currAtt->name));\n    if (! attId)\n      return XML_ERROR_NO_MEMORY;\n#ifdef XML_ATTR_INFO\n    currAttInfo->nameStart\n        = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);\n    currAttInfo->nameEnd\n        = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);\n    currAttInfo->valueStart = parser->m_parseEndByteIndex\n                              - (parser->m_parseEndPtr - currAtt->valuePtr);\n    currAttInfo->valueEnd = parser->m_parseEndByteIndex\n                            - (parser->m_parseEndPtr - currAtt->valueEnd);\n#endif\n    /* Detect duplicate attributes by their QNames. This does not work when\n       namespace processing is turned on and different prefixes for the same\n       namespace are used. For this case we have a check further down.\n    */\n    if ((attId->name)[-1]) {\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = parser->m_atts[i].name;\n      return XML_ERROR_DUPLICATE_ATTRIBUTE;\n    }\n    (attId->name)[-1] = 1;\n    appAtts[attIndex++] = attId->name;\n    if (! parser->m_atts[i].normalized) {\n      enum XML_Error result;\n      XML_Bool isCdata = XML_TRUE;\n\n      /* figure out whether declared as other than CDATA */\n      if (attId->maybeTokenized) {\n        int j;\n        for (j = 0; j < nDefaultAtts; j++) {\n          if (attId == elementType->defaultAtts[j].id) {\n            isCdata = elementType->defaultAtts[j].isCdata;\n            break;\n          }\n        }\n      }\n\n      /* normalize the attribute value */\n      result = storeAttributeValue(\n          parser, enc, isCdata, parser->m_atts[i].valuePtr,\n          parser->m_atts[i].valueEnd, &parser->m_tempPool, account);\n      if (result)\n        return result;\n      appAtts[attIndex] = poolStart(&parser->m_tempPool);\n      poolFinish(&parser->m_tempPool);\n    } else {\n      /* the value did not need normalizing */\n      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,\n                                          parser->m_atts[i].valuePtr,\n                                          parser->m_atts[i].valueEnd);\n      if (appAtts[attIndex] == 0)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_tempPool);\n    }\n    /* handle prefixed attribute names */\n    if (attId->prefix) {\n      if (attId->xmlns) {\n        /* deal with namespace declarations here */\n        enum XML_Error result = addBinding(parser, attId->prefix, attId,\n                                           appAtts[attIndex], bindingsPtr);\n        if (result)\n          return result;\n        --attIndex;\n      } else {\n        /* deal with other prefixed names later */\n        attIndex++;\n        nPrefixes++;\n        (attId->name)[-1] = 2;\n      }\n    } else\n      attIndex++;\n  }\n\n  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */\n  parser->m_nSpecifiedAtts = attIndex;\n  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {\n    for (i = 0; i < attIndex; i += 2)\n      if (appAtts[i] == elementType->idAtt->name) {\n        parser->m_idAttIndex = i;\n        break;\n      }\n  } else\n    parser->m_idAttIndex = -1;\n\n  /* do attribute defaulting */\n  for (i = 0; i < nDefaultAtts; i++) {\n    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;\n    if (! (da->id->name)[-1] && da->value) {\n      if (da->id->prefix) {\n        if (da->id->xmlns) {\n          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,\n                                             da->value, bindingsPtr);\n          if (result)\n            return result;\n        } else {\n          (da->id->name)[-1] = 2;\n          nPrefixes++;\n          appAtts[attIndex++] = da->id->name;\n          appAtts[attIndex++] = da->value;\n        }\n      } else {\n        (da->id->name)[-1] = 1;\n        appAtts[attIndex++] = da->id->name;\n        appAtts[attIndex++] = da->value;\n      }\n    }\n  }\n  appAtts[attIndex] = 0;\n\n  /* expand prefixed attribute names, check for duplicates,\n     and clear flags that say whether attributes were specified */\n  i = 0;\n  if (nPrefixes) {\n    unsigned int j; /* hash table index */\n    unsigned long version = parser->m_nsAttsVersion;\n\n    /* Detect and prevent invalid shift */\n    if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {\n      return XML_ERROR_NO_MEMORY;\n    }\n\n    unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;\n    unsigned char oldNsAttsPower = parser->m_nsAttsPower;\n    /* size of hash table must be at least 2 * (# of prefixed attributes) */\n    if ((nPrefixes << 1)\n        >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */\n      NS_ATT *temp;\n      /* hash table size must also be a power of 2 and >= 8 */\n      while (nPrefixes >> parser->m_nsAttsPower++)\n        ;\n      if (parser->m_nsAttsPower < 3)\n        parser->m_nsAttsPower = 3;\n\n      /* Detect and prevent invalid shift */\n      if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n\n      nsAttsSize = 1u << parser->m_nsAttsPower;\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if (nsAttsSize > SIZE_MAX / sizeof(NS_ATT)) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n#endif\n\n      temp = REALLOC(parser, parser->m_nsAtts, nsAttsSize * sizeof(NS_ATT));\n      if (! temp) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n      parser->m_nsAtts = temp;\n      version = 0; /* force re-initialization of m_nsAtts hash table */\n    }\n    /* using a version flag saves us from initializing m_nsAtts every time */\n    if (! version) { /* initialize version flags when version wraps around */\n      version = INIT_ATTS_VERSION;\n      for (j = nsAttsSize; j != 0;)\n        parser->m_nsAtts[--j].version = version;\n    }\n    parser->m_nsAttsVersion = --version;\n\n    /* expand prefixed names and check for duplicates */\n    for (; i < attIndex; i += 2) {\n      const XML_Char *s = appAtts[i];\n      if (s[-1] == 2) { /* prefixed */\n        ATTRIBUTE_ID *id;\n        const BINDING *b;\n        unsigned long uriHash;\n        struct siphash sip_state;\n        struct sipkey sip_key;\n\n        copy_salt_to_sipkey(parser, &sip_key);\n        sip24_init(&sip_state, &sip_key);\n\n        ((XML_Char *)s)[-1] = 0; /* clear flag */\n        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);\n        if (! id || ! id->prefix) {\n          /* This code is walking through the appAtts array, dealing\n           * with (in this case) a prefixed attribute name.  To be in\n           * the array, the attribute must have already been bound, so\n           * has to have passed through the hash table lookup once\n           * already.  That implies that an entry for it already\n           * exists, so the lookup above will return a pointer to\n           * already allocated memory.  There is no opportunaity for\n           * the allocator to fail, so the condition above cannot be\n           * fulfilled.\n           *\n           * Since it is difficult to be certain that the above\n           * analysis is complete, we retain the test and merely\n           * remove the code from coverage tests.\n           */\n          return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */\n        }\n        b = id->prefix->binding;\n        if (! b)\n          return XML_ERROR_UNBOUND_PREFIX;\n\n        for (j = 0; j < (unsigned int)b->uriLen; j++) {\n          const XML_Char c = b->uri[j];\n          if (! poolAppendChar(&parser->m_tempPool, c))\n            return XML_ERROR_NO_MEMORY;\n        }\n\n        sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));\n\n        while (*s++ != XML_T(ASCII_COLON))\n          ;\n\n        sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));\n\n        do { /* copies null terminator */\n          if (! poolAppendChar(&parser->m_tempPool, *s))\n            return XML_ERROR_NO_MEMORY;\n        } while (*s++);\n\n        uriHash = (unsigned long)sip24_final(&sip_state);\n\n        { /* Check hash table for duplicate of expanded name (uriName).\n             Derived from code in lookup(parser, HASH_TABLE *table, ...).\n          */\n          unsigned char step = 0;\n          unsigned long mask = nsAttsSize - 1;\n          j = uriHash & mask; /* index into hash table */\n          while (parser->m_nsAtts[j].version == version) {\n            /* for speed we compare stored hash values first */\n            if (uriHash == parser->m_nsAtts[j].hash) {\n              const XML_Char *s1 = poolStart(&parser->m_tempPool);\n              const XML_Char *s2 = parser->m_nsAtts[j].uriName;\n              /* s1 is null terminated, but not s2 */\n              for (; *s1 == *s2 && *s1 != 0; s1++, s2++)\n                ;\n              if (*s1 == 0)\n                return XML_ERROR_DUPLICATE_ATTRIBUTE;\n            }\n            if (! step)\n              step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);\n            j < step ? (j += nsAttsSize - step) : (j -= step);\n          }\n        }\n\n        if (parser->m_ns_triplets) { /* append namespace separator and prefix */\n          parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;\n          s = b->prefix->name;\n          do {\n            if (! poolAppendChar(&parser->m_tempPool, *s))\n              return XML_ERROR_NO_MEMORY;\n          } while (*s++);\n        }\n\n        /* store expanded name in attribute list */\n        s = poolStart(&parser->m_tempPool);\n        poolFinish(&parser->m_tempPool);\n        appAtts[i] = s;\n\n        /* fill empty slot with new version, uriName and hash value */\n        parser->m_nsAtts[j].version = version;\n        parser->m_nsAtts[j].hash = uriHash;\n        parser->m_nsAtts[j].uriName = s;\n\n        if (! --nPrefixes) {\n          i += 2;\n          break;\n        }\n      } else                     /* not prefixed */\n        ((XML_Char *)s)[-1] = 0; /* clear flag */\n    }\n  }\n  /* clear flags for the remaining attributes */\n  for (; i < attIndex; i += 2)\n    ((XML_Char *)(appAtts[i]))[-1] = 0;\n  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)\n    binding->attId->name[-1] = 0;\n\n  if (! parser->m_ns)\n    return XML_ERROR_NONE;\n\n  /* expand the element type name */\n  if (elementType->prefix) {\n    binding = elementType->prefix->binding;\n    if (! binding)\n      return XML_ERROR_UNBOUND_PREFIX;\n    localPart = tagNamePtr->str;\n    while (*localPart++ != XML_T(ASCII_COLON))\n      ;\n  } else if (dtd->defaultPrefix.binding) {\n    binding = dtd->defaultPrefix.binding;\n    localPart = tagNamePtr->str;\n  } else\n    return XML_ERROR_NONE;\n  prefixLen = 0;\n  if (parser->m_ns_triplets && binding->prefix->name) {\n    while (binding->prefix->name[prefixLen++])\n      ; /* prefixLen includes null terminator */\n  }\n  tagNamePtr->localPart = localPart;\n  tagNamePtr->uriLen = binding->uriLen;\n  tagNamePtr->prefix = binding->prefix->name;\n  tagNamePtr->prefixLen = prefixLen;\n  for (i = 0; localPart[i++];)\n    ; /* i includes null terminator */\n\n  /* Detect and prevent integer overflow */\n  if (binding->uriLen > INT_MAX - prefixLen\n      || i > INT_MAX - (binding->uriLen + prefixLen)) {\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  n = i + binding->uriLen + prefixLen;\n  if (n > binding->uriAlloc) {\n    TAG *p;\n\n    /* Detect and prevent integer overflow */\n    if (n > INT_MAX - EXPAND_SPARE) {\n      return XML_ERROR_NO_MEMORY;\n    }\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)(n + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    uri = MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));\n    if (! uri)\n      return XML_ERROR_NO_MEMORY;\n    binding->uriAlloc = n + EXPAND_SPARE;\n    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));\n    for (p = parser->m_tagStack; p; p = p->parent)\n      if (p->name.str == binding->uri)\n        p->name.str = uri;\n    FREE(parser, binding->uri);\n    binding->uri = uri;\n  }\n  /* if m_namespaceSeparator != '\\0' then uri includes it already */\n  uri = binding->uri + binding->uriLen;\n  memcpy(uri, localPart, i * sizeof(XML_Char));\n  /* we always have a namespace separator between localPart and prefix */\n  if (prefixLen) {\n    uri += i - 1;\n    *uri = parser->m_namespaceSeparator; /* replace null terminator */\n    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));\n  }\n  tagNamePtr->str = binding->uri;\n  return XML_ERROR_NONE;\n}\n\nstatic XML_Bool\nis_rfc3986_uri_char(XML_Char candidate) {\n  // For the RFC 3986 ANBF grammar see\n  // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A\n\n  switch (candidate) {\n  // From rule \"ALPHA\" (uppercase half)\n  case 'A':\n  case 'B':\n  case 'C':\n  case 'D':\n  case 'E':\n  case 'F':\n  case 'G':\n  case 'H':\n  case 'I':\n  case 'J':\n  case 'K':\n  case 'L':\n  case 'M':\n  case 'N':\n  case 'O':\n  case 'P':\n  case 'Q':\n  case 'R':\n  case 'S':\n  case 'T':\n  case 'U':\n  case 'V':\n  case 'W':\n  case 'X':\n  case 'Y':\n  case 'Z':\n\n  // From rule \"ALPHA\" (lowercase half)\n  case 'a':\n  case 'b':\n  case 'c':\n  case 'd':\n  case 'e':\n  case 'f':\n  case 'g':\n  case 'h':\n  case 'i':\n  case 'j':\n  case 'k':\n  case 'l':\n  case 'm':\n  case 'n':\n  case 'o':\n  case 'p':\n  case 'q':\n  case 'r':\n  case 's':\n  case 't':\n  case 'u':\n  case 'v':\n  case 'w':\n  case 'x':\n  case 'y':\n  case 'z':\n\n  // From rule \"DIGIT\"\n  case '0':\n  case '1':\n  case '2':\n  case '3':\n  case '4':\n  case '5':\n  case '6':\n  case '7':\n  case '8':\n  case '9':\n\n  // From rule \"pct-encoded\"\n  case '%':\n\n  // From rule \"unreserved\"\n  case '-':\n  case '.':\n  case '_':\n  case '~':\n\n  // From rule \"gen-delims\"\n  case ':':\n  case '/':\n  case '?':\n  case '#':\n  case '[':\n  case ']':\n  case '@':\n\n  // From rule \"sub-delims\"\n  case '!':\n  case '$':\n  case '&':\n  case '\\'':\n  case '(':\n  case ')':\n  case '*':\n  case '+':\n  case ',':\n  case ';':\n  case '=':\n    return XML_TRUE;\n\n  default:\n    return XML_FALSE;\n  }\n}\n\n/* addBinding() overwrites the value of prefix->binding without checking.\n   Therefore one must keep track of the old value outside of addBinding().\n*/\nstatic enum XML_Error\naddBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,\n           const XML_Char *uri, BINDING **bindingsPtr) {\n  // \"http://www.w3.org/XML/1998/namespace\"\n  static const XML_Char xmlNamespace[]\n      = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,\n         ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,\n         ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,\n         ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,\n         ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,\n         ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,\n         ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,\n         ASCII_e,      '\\0'};\n  static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;\n  // \"http://www.w3.org/2000/xmlns/\"\n  static const XML_Char xmlnsNamespace[]\n      = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,\n         ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,\n         ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,\n         ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,\n         ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\\0'};\n  static const int xmlnsLen\n      = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;\n\n  XML_Bool mustBeXML = XML_FALSE;\n  XML_Bool isXML = XML_TRUE;\n  XML_Bool isXMLNS = XML_TRUE;\n\n  BINDING *b;\n  int len;\n\n  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */\n  if (*uri == XML_T('\\0') && prefix->name)\n    return XML_ERROR_UNDECLARING_PREFIX;\n\n  if (prefix->name && prefix->name[0] == XML_T(ASCII_x)\n      && prefix->name[1] == XML_T(ASCII_m)\n      && prefix->name[2] == XML_T(ASCII_l)) {\n    /* Not allowed to bind xmlns */\n    if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)\n        && prefix->name[5] == XML_T('\\0'))\n      return XML_ERROR_RESERVED_PREFIX_XMLNS;\n\n    if (prefix->name[3] == XML_T('\\0'))\n      mustBeXML = XML_TRUE;\n  }\n\n  for (len = 0; uri[len]; len++) {\n    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))\n      isXML = XML_FALSE;\n\n    if (! mustBeXML && isXMLNS\n        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))\n      isXMLNS = XML_FALSE;\n\n    // NOTE: While Expat does not validate namespace URIs against RFC 3986\n    //       today (and is not REQUIRED to do so with regard to the XML 1.0\n    //       namespaces specification) we have to at least make sure, that\n    //       the application on top of Expat (that is likely splitting expanded\n    //       element names (\"qualified names\") of form\n    //       \"[uri sep] local [sep prefix] '\\0'\" back into 1, 2 or 3 pieces\n    //       in its element handler code) cannot be confused by an attacker\n    //       putting additional namespace separator characters into namespace\n    //       declarations.  That would be ambiguous and not to be expected.\n    //\n    //       While the HTML API docs of function XML_ParserCreateNS have been\n    //       advising against use of a namespace separator character that can\n    //       appear in a URI for >20 years now, some widespread applications\n    //       are using URI characters (':' (colon) in particular) for a\n    //       namespace separator, in practice.  To keep these applications\n    //       functional, we only reject namespaces URIs containing the\n    //       application-chosen namespace separator if the chosen separator\n    //       is a non-URI character with regard to RFC 3986.\n    if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)\n        && ! is_rfc3986_uri_char(uri[len])) {\n      return XML_ERROR_SYNTAX;\n    }\n  }\n  isXML = isXML && len == xmlLen;\n  isXMLNS = isXMLNS && len == xmlnsLen;\n\n  if (mustBeXML != isXML)\n    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML\n                     : XML_ERROR_RESERVED_NAMESPACE_URI;\n\n  if (isXMLNS)\n    return XML_ERROR_RESERVED_NAMESPACE_URI;\n\n  if (parser->m_namespaceSeparator)\n    len++;\n  if (parser->m_freeBindingList) {\n    b = parser->m_freeBindingList;\n    if (len > b->uriAlloc) {\n      /* Detect and prevent integer overflow */\n      if (len > INT_MAX - EXPAND_SPARE) {\n        return XML_ERROR_NO_MEMORY;\n      }\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((unsigned)(len + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n        return XML_ERROR_NO_MEMORY;\n      }\n#endif\n\n      XML_Char *temp\n          = REALLOC(parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));\n      if (temp == NULL)\n        return XML_ERROR_NO_MEMORY;\n      b->uri = temp;\n      b->uriAlloc = len + EXPAND_SPARE;\n    }\n    parser->m_freeBindingList = b->nextTagBinding;\n  } else {\n    b = MALLOC(parser, sizeof(BINDING));\n    if (! b)\n      return XML_ERROR_NO_MEMORY;\n\n    /* Detect and prevent integer overflow */\n    if (len > INT_MAX - EXPAND_SPARE) {\n      return XML_ERROR_NO_MEMORY;\n    }\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)(len + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    b->uri = MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));\n    if (! b->uri) {\n      FREE(parser, b);\n      return XML_ERROR_NO_MEMORY;\n    }\n    b->uriAlloc = len + EXPAND_SPARE;\n  }\n  b->uriLen = len;\n  memcpy(b->uri, uri, len * sizeof(XML_Char));\n  if (parser->m_namespaceSeparator)\n    b->uri[len - 1] = parser->m_namespaceSeparator;\n  b->prefix = prefix;\n  b->attId = attId;\n  b->prevPrefixBinding = prefix->binding;\n  /* NULL binding when default namespace undeclared */\n  if (*uri == XML_T('\\0') && prefix == &parser->m_dtd->defaultPrefix)\n    prefix->binding = NULL;\n  else\n    prefix->binding = b;\n  b->nextTagBinding = *bindingsPtr;\n  *bindingsPtr = b;\n  /* if attId == NULL then we are not starting a namespace scope */\n  if (attId && parser->m_startNamespaceDeclHandler)\n    parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,\n                                        prefix->binding ? uri : 0);\n  return XML_ERROR_NONE;\n}\n\n/* The idea here is to avoid using stack for each CDATA section when\n   the whole file is parsed with one call.\n*/\nstatic enum XML_Error PTRCALL\ncdataSectionProcessor(XML_Parser parser, const char *start, const char *end,\n                      const char **endPtr) {\n  enum XML_Error result = doCdataSection(\n      parser, parser->m_encoding, &start, end, endPtr,\n      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);\n  if (result != XML_ERROR_NONE)\n    return result;\n  if (start) {\n    if (parser->m_parentParser) { /* we are parsing an external entity */\n      parser->m_processor = externalEntityContentProcessor;\n      return externalEntityContentProcessor(parser, start, end, endPtr);\n    } else {\n      parser->m_processor = contentProcessor;\n      return contentProcessor(parser, start, end, endPtr);\n    }\n  }\n  return result;\n}\n\n/* startPtr gets set to non-null if the section is closed, and to null if\n   the section is not yet closed.\n*/\nstatic enum XML_Error\ndoCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,\n               const char *end, const char **nextPtr, XML_Bool haveMore,\n               enum XML_Account account) {\n  const char *s = *startPtr;\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    *eventPP = s;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n  *eventPP = s;\n  *startPtr = NULL;\n\n  for (;;) {\n    const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */\n    int tok = XmlCdataSectionTok(enc, s, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#else\n    UNUSED_P(account);\n#endif\n    *eventEndPP = next;\n    switch (tok) {\n    case XML_TOK_CDATA_SECT_CLOSE:\n      if (parser->m_endCdataSectionHandler)\n        parser->m_endCdataSectionHandler(parser->m_handlerArg);\n      /* BEGIN disabled code */\n      /* see comment under XML_TOK_CDATA_SECT_OPEN */\n      else if ((0) && parser->m_characterDataHandler)\n        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                                       0);\n      /* END disabled code */\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      *startPtr = next;\n      *nextPtr = next;\n      if (parser->m_parsingStatus.parsing == XML_FINISHED)\n        return XML_ERROR_ABORTED;\n      else\n        return XML_ERROR_NONE;\n    case XML_TOK_DATA_NEWLINE:\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    case XML_TOK_DATA_CHARS: {\n      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;\n      if (charDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          for (;;) {\n            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n            const enum XML_Convert_Result convert_res = XmlConvert(\n                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n            *eventEndPP = next;\n            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n            if ((convert_res == XML_CONVERT_COMPLETED)\n                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n              break;\n            *eventPP = s;\n          }\n        } else\n          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,\n                          (int)((const XML_Char *)next - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_INVALID:\n      *eventPP = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_PARTIAL:\n    case XML_TOK_NONE:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_CDATA_SECTION;\n    default:\n      /* Every token returned by XmlCdataSectionTok() has its own\n       * explicit case, so this default case will never be executed.\n       * We retain it as a safety net and exclude it from the coverage\n       * statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      *eventPP = next;\n      return XML_ERROR_UNEXPECTED_STATE;\n      /* LCOV_EXCL_STOP */\n    }\n\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *eventPP = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      *eventPP = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n      /* Fall through */\n    default:;\n      *eventPP = s = next;\n    }\n  }\n  /* not reached */\n}\n\n#ifdef XML_DTD\n\n/* The idea here is to avoid using stack for each IGNORE section when\n   the whole file is parsed with one call.\n*/\nstatic enum XML_Error PTRCALL\nignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,\n                       const char **endPtr) {\n  enum XML_Error result\n      = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,\n                        (XML_Bool)! parser->m_parsingStatus.finalBuffer);\n  if (result != XML_ERROR_NONE)\n    return result;\n  if (start) {\n    parser->m_processor = prologProcessor;\n    return prologProcessor(parser, start, end, endPtr);\n  }\n  return result;\n}\n\n/* startPtr gets set to non-null is the section is closed, and to null\n   if the section is not yet closed.\n*/\nstatic enum XML_Error\ndoIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,\n                const char *end, const char **nextPtr, XML_Bool haveMore) {\n  const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */\n  int tok;\n  const char *s = *startPtr;\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    *eventPP = s;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    /* It's not entirely clear, but it seems the following two lines\n     * of code cannot be executed.  The only occasions on which 'enc'\n     * is not 'encoding' are when this function is called\n     * from the internal entity processing, and IGNORE sections are an\n     * error in internal entities.\n     *\n     * Since it really isn't clear that this is true, we keep the code\n     * and just remove it from our coverage tests.\n     *\n     * LCOV_EXCL_START\n     */\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n    /* LCOV_EXCL_STOP */\n  }\n  *eventPP = s;\n  *startPtr = NULL;\n  tok = XmlIgnoreSectionTok(enc, s, end, &next);\n#  if XML_GE == 1\n  if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                XML_ACCOUNT_DIRECT)) {\n    accountingOnAbort(parser);\n    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n  }\n#  endif\n  *eventEndPP = next;\n  switch (tok) {\n  case XML_TOK_IGNORE_SECT:\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, s, next);\n    *startPtr = next;\n    *nextPtr = next;\n    if (parser->m_parsingStatus.parsing == XML_FINISHED)\n      return XML_ERROR_ABORTED;\n    else\n      return XML_ERROR_NONE;\n  case XML_TOK_INVALID:\n    *eventPP = next;\n    return XML_ERROR_INVALID_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (haveMore) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_PARTIAL_CHAR;\n  case XML_TOK_PARTIAL:\n  case XML_TOK_NONE:\n    if (haveMore) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */\n  default:\n    /* All of the tokens that XmlIgnoreSectionTok() returns have\n     * explicit cases to handle them, so this default case is never\n     * executed.  We keep it as a safety net anyway, and remove it\n     * from our test coverage statistics.\n     *\n     * LCOV_EXCL_START\n     */\n    *eventPP = next;\n    return XML_ERROR_UNEXPECTED_STATE;\n    /* LCOV_EXCL_STOP */\n  }\n  /* not reached */\n}\n\n#endif /* XML_DTD */\n\nstatic enum XML_Error\ninitializeEncoding(XML_Parser parser) {\n  const char *s;\n#ifdef XML_UNICODE\n  char encodingBuf[128];\n  /* See comments about `protocolEncodingName` in parserInit() */\n  if (! parser->m_protocolEncodingName)\n    s = NULL;\n  else {\n    int i;\n    for (i = 0; parser->m_protocolEncodingName[i]; i++) {\n      if (i == sizeof(encodingBuf) - 1\n          || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {\n        encodingBuf[0] = '\\0';\n        break;\n      }\n      encodingBuf[i] = (char)parser->m_protocolEncodingName[i];\n    }\n    encodingBuf[i] = '\\0';\n    s = encodingBuf;\n  }\n#else\n  s = parser->m_protocolEncodingName;\n#endif\n  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(\n          &parser->m_initEncoding, &parser->m_encoding, s))\n    return XML_ERROR_NONE;\n  return handleUnknownEncoding(parser, parser->m_protocolEncodingName);\n}\n\nstatic enum XML_Error\nprocessXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,\n               const char *next) {\n  const char *encodingName = NULL;\n  const XML_Char *storedEncName = NULL;\n  const ENCODING *newEncoding = NULL;\n  const char *version = NULL;\n  const char *versionend = NULL;\n  const XML_Char *storedversion = NULL;\n  int standalone = -1;\n\n#if XML_GE == 1\n  if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,\n                                XML_ACCOUNT_DIRECT)) {\n    accountingOnAbort(parser);\n    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n  }\n#endif\n\n  if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(\n          isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,\n          &version, &versionend, &encodingName, &newEncoding, &standalone)) {\n    if (isGeneralTextEntity)\n      return XML_ERROR_TEXT_DECL;\n    else\n      return XML_ERROR_XML_DECL;\n  }\n  if (! isGeneralTextEntity && standalone == 1) {\n    parser->m_dtd->standalone = XML_TRUE;\n#ifdef XML_DTD\n    if (parser->m_paramEntityParsing\n        == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)\n      parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\n#endif /* XML_DTD */\n  }\n  if (parser->m_xmlDeclHandler) {\n    if (encodingName != NULL) {\n      storedEncName = poolStoreString(\n          &parser->m_temp2Pool, parser->m_encoding, encodingName,\n          encodingName + XmlNameLength(parser->m_encoding, encodingName));\n      if (! storedEncName)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_temp2Pool);\n    }\n    if (version) {\n      storedversion\n          = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,\n                            versionend - parser->m_encoding->minBytesPerChar);\n      if (! storedversion)\n        return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,\n                             standalone);\n  } else if (parser->m_defaultHandler)\n    reportDefault(parser, parser->m_encoding, s, next);\n  if (parser->m_protocolEncodingName == NULL) {\n    if (newEncoding) {\n      /* Check that the specified encoding does not conflict with what\n       * the parser has already deduced.  Do we have the same number\n       * of bytes in the smallest representation of a character?  If\n       * this is UTF-16, is it the same endianness?\n       */\n      if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar\n          || (newEncoding->minBytesPerChar == 2\n              && newEncoding != parser->m_encoding)) {\n        parser->m_eventPtr = encodingName;\n        return XML_ERROR_INCORRECT_ENCODING;\n      }\n      parser->m_encoding = newEncoding;\n    } else if (encodingName) {\n      enum XML_Error result;\n      if (! storedEncName) {\n        storedEncName = poolStoreString(\n            &parser->m_temp2Pool, parser->m_encoding, encodingName,\n            encodingName + XmlNameLength(parser->m_encoding, encodingName));\n        if (! storedEncName)\n          return XML_ERROR_NO_MEMORY;\n      }\n      result = handleUnknownEncoding(parser, storedEncName);\n      poolClear(&parser->m_temp2Pool);\n      if (result == XML_ERROR_UNKNOWN_ENCODING)\n        parser->m_eventPtr = encodingName;\n      return result;\n    }\n  }\n\n  if (storedEncName || storedversion)\n    poolClear(&parser->m_temp2Pool);\n\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error\nhandleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {\n  if (parser->m_unknownEncodingHandler) {\n    XML_Encoding info;\n    int i;\n    for (i = 0; i < 256; i++)\n      info.map[i] = -1;\n    info.convert = NULL;\n    info.data = NULL;\n    info.release = NULL;\n    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,\n                                         encodingName, &info)) {\n      ENCODING *enc;\n      parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());\n      if (! parser->m_unknownEncodingMem) {\n        if (info.release)\n          info.release(info.data);\n        return XML_ERROR_NO_MEMORY;\n      }\n      enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(\n          parser->m_unknownEncodingMem, info.map, info.convert, info.data);\n      if (enc) {\n        parser->m_unknownEncodingData = info.data;\n        parser->m_unknownEncodingRelease = info.release;\n        parser->m_encoding = enc;\n        return XML_ERROR_NONE;\n      }\n    }\n    if (info.release != NULL)\n      info.release(info.data);\n  }\n  return XML_ERROR_UNKNOWN_ENCODING;\n}\n\nstatic enum XML_Error PTRCALL\nprologInitProcessor(XML_Parser parser, const char *s, const char *end,\n                    const char **nextPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n  parser->m_processor = prologProcessor;\n  return prologProcessor(parser, s, end, nextPtr);\n}\n\n#ifdef XML_DTD\n\nstatic enum XML_Error PTRCALL\nexternalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,\n                            const char **nextPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n\n  /* we know now that XML_Parse(Buffer) has been called,\n     so we consider the external parameter entity read */\n  parser->m_dtd->paramEntityRead = XML_TRUE;\n\n  if (parser->m_prologState.inEntityValue) {\n    parser->m_processor = entityValueInitProcessor;\n    return entityValueInitProcessor(parser, s, end, nextPtr);\n  } else {\n    parser->m_processor = externalParEntProcessor;\n    return externalParEntProcessor(parser, s, end, nextPtr);\n  }\n}\n\nstatic enum XML_Error PTRCALL\nentityValueInitProcessor(XML_Parser parser, const char *s, const char *end,\n                         const char **nextPtr) {\n  int tok;\n  const char *start = s;\n  const char *next = start;\n  parser->m_eventPtr = start;\n\n  for (;;) {\n    tok = XmlPrologTok(parser->m_encoding, start, end, &next);\n    /* Note: Except for XML_TOK_BOM below, these bytes are accounted later in:\n             - storeEntityValue\n             - processXmlDecl\n    */\n    parser->m_eventEndPtr = next;\n    if (tok <= 0) {\n      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case XML_TOK_NONE: /* start == end */\n      default:\n        break;\n      }\n      /* found end of entity value - can store it now */\n      return storeEntityValue(parser, parser->m_encoding, s, end,\n                              XML_ACCOUNT_DIRECT, NULL);\n    } else if (tok == XML_TOK_XML_DECL) {\n      enum XML_Error result;\n      result = processXmlDecl(parser, 0, start, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For\n       * that to happen, a parameter entity parsing handler must have attempted\n       * to suspend the parser, which fails and raises an error.  The parser can\n       * be aborted, but can't be suspended.\n       */\n      if (parser->m_parsingStatus.parsing == XML_FINISHED)\n        return XML_ERROR_ABORTED;\n      *nextPtr = next;\n      /* stop scanning for text declaration - we found one */\n      parser->m_processor = entityValueProcessor;\n      return entityValueProcessor(parser, next, end, nextPtr);\n    }\n    /* XmlPrologTok has now set the encoding based on the BOM it found, and we\n       must move s and nextPtr forward to consume the BOM.\n\n       If we didn't, and got XML_TOK_NONE from the next XmlPrologTok call, we\n       would leave the BOM in the buffer and return. On the next call to this\n       function, our XmlPrologTok call would return XML_TOK_INVALID, since it\n       is not valid to have multiple BOMs.\n    */\n    else if (tok == XML_TOK_BOM) {\n#  if XML_GE == 1\n      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                    XML_ACCOUNT_DIRECT)) {\n        accountingOnAbort(parser);\n        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      }\n#  endif\n\n      *nextPtr = next;\n      s = next;\n    }\n    /* If we get this token, we have the start of what might be a\n       normal tag, but not a declaration (i.e. it doesn't begin with\n       \"<!\" or \"<?\").  In a DTD context, that isn't legal.\n    */\n    else if (tok == XML_TOK_INSTANCE_START) {\n      *nextPtr = next;\n      return XML_ERROR_SYNTAX;\n    }\n    start = next;\n    parser->m_eventPtr = start;\n  }\n}\n\nstatic enum XML_Error PTRCALL\nexternalParEntProcessor(XML_Parser parser, const char *s, const char *end,\n                        const char **nextPtr) {\n  const char *next = s;\n  int tok;\n\n  tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  if (tok <= 0) {\n    if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    switch (tok) {\n    case XML_TOK_INVALID:\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_NONE: /* start == end */\n    default:\n      break;\n    }\n  }\n  /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.\n     However, when parsing an external subset, doProlog will not accept a BOM\n     as valid, and report a syntax error, so we have to skip the BOM, and\n     account for the BOM bytes.\n  */\n  else if (tok == XML_TOK_BOM) {\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n\n    s = next;\n    tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  }\n\n  parser->m_processor = prologProcessor;\n  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,\n                  XML_ACCOUNT_DIRECT);\n}\n\nstatic enum XML_Error PTRCALL\nentityValueProcessor(XML_Parser parser, const char *s, const char *end,\n                     const char **nextPtr) {\n  const char *start = s;\n  const char *next = s;\n  const ENCODING *enc = parser->m_encoding;\n  int tok;\n\n  for (;;) {\n    tok = XmlPrologTok(enc, start, end, &next);\n    /* Note: These bytes are accounted later in:\n             - storeEntityValue\n    */\n    if (tok <= 0) {\n      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case XML_TOK_NONE: /* start == end */\n      default:\n        break;\n      }\n      /* found end of entity value - can store it now */\n      return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT, NULL);\n    }\n    /* If we get this token, we have the start of what might be a\n       normal tag, but not a declaration (i.e. it doesn't begin with\n       \"<!\" or \"<?\").  In a DTD context, that isn't legal.\n    */\n    else if (tok == XML_TOK_INSTANCE_START) {\n      *nextPtr = next;\n      return XML_ERROR_SYNTAX;\n    }\n\n    start = next;\n  }\n}\n\n#endif /* XML_DTD */\n\nstatic enum XML_Error PTRCALL\nprologProcessor(XML_Parser parser, const char *s, const char *end,\n                const char **nextPtr) {\n  const char *next = s;\n  int tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,\n                  XML_ACCOUNT_DIRECT);\n}\n\nstatic enum XML_Error\ndoProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,\n         int tok, const char *next, const char **nextPtr, XML_Bool haveMore,\n         XML_Bool allowClosingDoctype, enum XML_Account account) {\n#ifdef XML_DTD\n  static const XML_Char externalSubsetName[] = {ASCII_HASH, '\\0'};\n#endif /* XML_DTD */\n  static const XML_Char atypeCDATA[]\n      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\\0'};\n  static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\\0'};\n  static const XML_Char atypeIDREF[]\n      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\\0'};\n  static const XML_Char atypeIDREFS[]\n      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\\0'};\n  static const XML_Char atypeENTITY[]\n      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\\0'};\n  static const XML_Char atypeENTITIES[]\n      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,\n         ASCII_I, ASCII_E, ASCII_S, '\\0'};\n  static const XML_Char atypeNMTOKEN[]\n      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\\0'};\n  static const XML_Char atypeNMTOKENS[]\n      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,\n         ASCII_E, ASCII_N, ASCII_S, '\\0'};\n  static const XML_Char notationPrefix[]\n      = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,\n         ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\\0'};\n  static const XML_Char enumValueSep[] = {ASCII_PIPE, '\\0'};\n  static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\\0'};\n\n#ifndef XML_DTD\n  UNUSED_P(account);\n#endif\n\n  /* save one level of indirection */\n  DTD *const dtd = parser->m_dtd;\n\n  const char **eventPP;\n  const char **eventEndPP;\n  enum XML_Content_Quant quant;\n\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n\n  for (;;) {\n    int role;\n    XML_Bool handleDefault = XML_TRUE;\n    *eventPP = s;\n    *eventEndPP = next;\n    if (tok <= 0) {\n      if (haveMore && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        *eventPP = next;\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case -XML_TOK_PROLOG_S:\n        tok = -tok;\n        break;\n      case XML_TOK_NONE:\n#ifdef XML_DTD\n        /* for internal PE NOT referenced between declarations */\n        if (enc != parser->m_encoding\n            && ! parser->m_openInternalEntities->betweenDecl) {\n          *nextPtr = s;\n          return XML_ERROR_NONE;\n        }\n        /* WFC: PE Between Declarations - must check that PE contains\n           complete markup, not only for external PEs, but also for\n           internal PEs if the reference occurs between declarations.\n        */\n        if (parser->m_isParamEntity || enc != parser->m_encoding) {\n          if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)\n              == XML_ROLE_ERROR)\n            return XML_ERROR_INCOMPLETE_PE;\n          *nextPtr = s;\n          return XML_ERROR_NONE;\n        }\n#endif /* XML_DTD */\n        return XML_ERROR_NO_ELEMENTS;\n      default:\n        tok = -tok;\n        next = end;\n        break;\n      }\n    }\n    role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);\n#if XML_GE == 1\n    switch (role) {\n    case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor\n    case XML_ROLE_XML_DECL:       // bytes accounted in processXmlDecl\n#  ifdef XML_DTD\n    case XML_ROLE_TEXT_DECL: // bytes accounted in processXmlDecl\n#  endif\n      break;\n    default:\n      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {\n        accountingOnAbort(parser);\n        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      }\n    }\n#endif\n    switch (role) {\n    case XML_ROLE_XML_DECL: {\n      enum XML_Error result = processXmlDecl(parser, 0, s, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      enc = parser->m_encoding;\n      handleDefault = XML_FALSE;\n    } break;\n    case XML_ROLE_DOCTYPE_NAME:\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_doctypeName\n            = poolStoreString(&parser->m_tempPool, enc, s, next);\n        if (! parser->m_doctypeName)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        parser->m_doctypePubid = NULL;\n        handleDefault = XML_FALSE;\n      }\n      parser->m_doctypeSysid = NULL; /* always initialize to NULL */\n      break;\n    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_startDoctypeDeclHandler(\n            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,\n            parser->m_doctypePubid, 1);\n        parser->m_doctypeName = NULL;\n        poolClear(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n#ifdef XML_DTD\n    case XML_ROLE_TEXT_DECL: {\n      enum XML_Error result = processXmlDecl(parser, 1, s, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      enc = parser->m_encoding;\n      handleDefault = XML_FALSE;\n    } break;\n#endif /* XML_DTD */\n    case XML_ROLE_DOCTYPE_PUBLIC_ID:\n#ifdef XML_DTD\n      parser->m_useForeignDTD = XML_FALSE;\n      parser->m_declEntity = (ENTITY *)lookup(\n          parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));\n      if (! parser->m_declEntity)\n        return XML_ERROR_NO_MEMORY;\n#endif /* XML_DTD */\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (parser->m_startDoctypeDeclHandler) {\n        XML_Char *pubId;\n        if (! XmlIsPublicId(enc, s, next, eventPP))\n          return XML_ERROR_PUBLICID;\n        pubId = poolStoreString(&parser->m_tempPool, enc,\n                                s + enc->minBytesPerChar,\n                                next - enc->minBytesPerChar);\n        if (! pubId)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(pubId);\n        poolFinish(&parser->m_tempPool);\n        parser->m_doctypePubid = pubId;\n        handleDefault = XML_FALSE;\n        goto alreadyChecked;\n      }\n      /* fall through */\n    case XML_ROLE_ENTITY_PUBLIC_ID:\n      if (! XmlIsPublicId(enc, s, next, eventPP))\n        return XML_ERROR_PUBLICID;\n    alreadyChecked:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        XML_Char *tem\n            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                              next - enc->minBytesPerChar);\n        if (! tem)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(tem);\n        parser->m_declEntity->publicId = tem;\n        poolFinish(&dtd->pool);\n        /* Don't suppress the default handler if we fell through from\n         * the XML_ROLE_DOCTYPE_PUBLIC_ID case.\n         */\n        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_DOCTYPE_CLOSE:\n      if (allowClosingDoctype != XML_TRUE) {\n        /* Must not close doctype from within expanded parameter entities */\n        return XML_ERROR_INVALID_TOKEN;\n      }\n\n      if (parser->m_doctypeName) {\n        parser->m_startDoctypeDeclHandler(\n            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,\n            parser->m_doctypePubid, 0);\n        poolClear(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      /* parser->m_doctypeSysid will be non-NULL in the case of a previous\n         XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler\n         was not set, indicating an external subset\n      */\n#ifdef XML_DTD\n      if (parser->m_doctypeSysid || parser->m_useForeignDTD) {\n        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\n        dtd->hasParamEntityRefs = XML_TRUE;\n        if (parser->m_paramEntityParsing\n            && parser->m_externalEntityRefHandler) {\n          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                            externalSubsetName, sizeof(ENTITY));\n          if (! entity) {\n            /* The external subset name \"#\" will have already been\n             * inserted into the hash table at the start of the\n             * external entity parsing, so no allocation will happen\n             * and lookup() cannot fail.\n             */\n            return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */\n          }\n          if (parser->m_useForeignDTD)\n            entity->base = parser->m_curBase;\n          dtd->paramEntityRead = XML_FALSE;\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId))\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          if (dtd->paramEntityRead) {\n            if (! dtd->standalone && parser->m_notStandaloneHandler\n                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n              return XML_ERROR_NOT_STANDALONE;\n          }\n          /* if we didn't read the foreign DTD then this means that there\n             is no external subset and we must reset dtd->hasParamEntityRefs\n          */\n          else if (! parser->m_doctypeSysid)\n            dtd->hasParamEntityRefs = hadParamEntityRefs;\n          /* end of DTD - no need to update dtd->keepProcessing */\n        }\n        parser->m_useForeignDTD = XML_FALSE;\n      }\n#endif /* XML_DTD */\n      if (parser->m_endDoctypeDeclHandler) {\n        parser->m_endDoctypeDeclHandler(parser->m_handlerArg);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_INSTANCE_START:\n#ifdef XML_DTD\n      /* if there is no DOCTYPE declaration then now is the\n         last chance to read the foreign DTD\n      */\n      if (parser->m_useForeignDTD) {\n        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\n        dtd->hasParamEntityRefs = XML_TRUE;\n        if (parser->m_paramEntityParsing\n            && parser->m_externalEntityRefHandler) {\n          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                            externalSubsetName, sizeof(ENTITY));\n          if (! entity)\n            return XML_ERROR_NO_MEMORY;\n          entity->base = parser->m_curBase;\n          dtd->paramEntityRead = XML_FALSE;\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId))\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          if (dtd->paramEntityRead) {\n            if (! dtd->standalone && parser->m_notStandaloneHandler\n                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n              return XML_ERROR_NOT_STANDALONE;\n          }\n          /* if we didn't read the foreign DTD then this means that there\n             is no external subset and we must reset dtd->hasParamEntityRefs\n          */\n          else\n            dtd->hasParamEntityRefs = hadParamEntityRefs;\n          /* end of DTD - no need to update dtd->keepProcessing */\n        }\n      }\n#endif /* XML_DTD */\n      parser->m_processor = contentProcessor;\n      return contentProcessor(parser, s, end, nextPtr);\n    case XML_ROLE_ATTLIST_ELEMENT_NAME:\n      parser->m_declElementType = getElementType(parser, enc, s, next);\n      if (! parser->m_declElementType)\n        return XML_ERROR_NO_MEMORY;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_NAME:\n      parser->m_declAttributeId = getAttributeId(parser, enc, s, next);\n      if (! parser->m_declAttributeId)\n        return XML_ERROR_NO_MEMORY;\n      parser->m_declAttributeIsCdata = XML_FALSE;\n      parser->m_declAttributeType = NULL;\n      parser->m_declAttributeIsId = XML_FALSE;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:\n      parser->m_declAttributeIsCdata = XML_TRUE;\n      parser->m_declAttributeType = atypeCDATA;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ID:\n      parser->m_declAttributeIsId = XML_TRUE;\n      parser->m_declAttributeType = atypeID;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:\n      parser->m_declAttributeType = atypeIDREF;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:\n      parser->m_declAttributeType = atypeIDREFS;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:\n      parser->m_declAttributeType = atypeENTITY;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:\n      parser->m_declAttributeType = atypeENTITIES;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:\n      parser->m_declAttributeType = atypeNMTOKEN;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:\n      parser->m_declAttributeType = atypeNMTOKENS;\n    checkAttListDeclHandler:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:\n    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler) {\n        const XML_Char *prefix;\n        if (parser->m_declAttributeType) {\n          prefix = enumValueSep;\n        } else {\n          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix\n                                                              : enumValueStart);\n        }\n        if (! poolAppendString(&parser->m_tempPool, prefix))\n          return XML_ERROR_NO_MEMORY;\n        if (! poolAppend(&parser->m_tempPool, enc, s, next))\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declAttributeType = parser->m_tempPool.start;\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:\n    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:\n      if (dtd->keepProcessing) {\n        if (! defineAttribute(parser->m_declElementType,\n                              parser->m_declAttributeId,\n                              parser->m_declAttributeIsCdata,\n                              parser->m_declAttributeIsId, 0, parser))\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {\n          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)\n              || (*parser->m_declAttributeType == XML_T(ASCII_N)\n                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {\n            /* Enumerated or Notation type */\n            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))\n                || ! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n              return XML_ERROR_NO_MEMORY;\n            parser->m_declAttributeType = parser->m_tempPool.start;\n            poolFinish(&parser->m_tempPool);\n          }\n          *eventEndPP = s;\n          parser->m_attlistDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name,\n              parser->m_declAttributeId->name, parser->m_declAttributeType, 0,\n              role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);\n          handleDefault = XML_FALSE;\n        }\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:\n    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:\n      if (dtd->keepProcessing) {\n        const XML_Char *attVal;\n        enum XML_Error result = storeAttributeValue(\n            parser, enc, parser->m_declAttributeIsCdata,\n            s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,\n            XML_ACCOUNT_NONE);\n        if (result)\n          return result;\n        attVal = poolStart(&dtd->pool);\n        poolFinish(&dtd->pool);\n        /* ID attributes aren't allowed to have a default */\n        if (! defineAttribute(\n                parser->m_declElementType, parser->m_declAttributeId,\n                parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {\n          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)\n              || (*parser->m_declAttributeType == XML_T(ASCII_N)\n                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {\n            /* Enumerated or Notation type */\n            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))\n                || ! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n              return XML_ERROR_NO_MEMORY;\n            parser->m_declAttributeType = parser->m_tempPool.start;\n            poolFinish(&parser->m_tempPool);\n          }\n          *eventEndPP = s;\n          parser->m_attlistDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name,\n              parser->m_declAttributeId->name, parser->m_declAttributeType,\n              attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);\n          poolClear(&parser->m_tempPool);\n          handleDefault = XML_FALSE;\n        }\n      }\n      break;\n    case XML_ROLE_ENTITY_VALUE:\n      if (dtd->keepProcessing) {\n#if XML_GE == 1\n        // This will store the given replacement text in\n        // parser->m_declEntity->textPtr.\n        enum XML_Error result = callStoreEntityValue(\n            parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar,\n            XML_ACCOUNT_NONE);\n        if (parser->m_declEntity) {\n          parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);\n          parser->m_declEntity->textLen\n              = (int)(poolLength(&dtd->entityValuePool));\n          poolFinish(&dtd->entityValuePool);\n          if (parser->m_entityDeclHandler) {\n            *eventEndPP = s;\n            parser->m_entityDeclHandler(\n                parser->m_handlerArg, parser->m_declEntity->name,\n                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,\n                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);\n            handleDefault = XML_FALSE;\n          }\n        } else\n          poolDiscard(&dtd->entityValuePool);\n        if (result != XML_ERROR_NONE)\n          return result;\n#else\n        // This will store \"&amp;entity123;\" in parser->m_declEntity->textPtr\n        // to end up as \"&entity123;\" in the handler.\n        if (parser->m_declEntity != NULL) {\n          const enum XML_Error result\n              = storeSelfEntityValue(parser, parser->m_declEntity);\n          if (result != XML_ERROR_NONE)\n            return result;\n\n          if (parser->m_entityDeclHandler) {\n            *eventEndPP = s;\n            parser->m_entityDeclHandler(\n                parser->m_handlerArg, parser->m_declEntity->name,\n                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,\n                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);\n            handleDefault = XML_FALSE;\n          }\n        }\n#endif\n      }\n      break;\n    case XML_ROLE_DOCTYPE_SYSTEM_ID:\n#ifdef XML_DTD\n      parser->m_useForeignDTD = XML_FALSE;\n#endif /* XML_DTD */\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,\n                                                 s + enc->minBytesPerChar,\n                                                 next - enc->minBytesPerChar);\n        if (parser->m_doctypeSysid == NULL)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n#ifdef XML_DTD\n      else\n        /* use externalSubsetName to make parser->m_doctypeSysid non-NULL\n           for the case where no parser->m_startDoctypeDeclHandler is set */\n        parser->m_doctypeSysid = externalSubsetName;\n#endif /* XML_DTD */\n      if (! dtd->standalone\n#ifdef XML_DTD\n          && ! parser->m_paramEntityParsing\n#endif /* XML_DTD */\n          && parser->m_notStandaloneHandler\n          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n        return XML_ERROR_NOT_STANDALONE;\n#ifndef XML_DTD\n      break;\n#else  /* XML_DTD */\n      if (! parser->m_declEntity) {\n        parser->m_declEntity = (ENTITY *)lookup(\n            parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity->publicId = NULL;\n      }\n#endif /* XML_DTD */\n      /* fall through */\n    case XML_ROLE_ENTITY_SYSTEM_ID:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        parser->m_declEntity->systemId\n            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                              next - enc->minBytesPerChar);\n        if (! parser->m_declEntity->systemId)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity->base = parser->m_curBase;\n        poolFinish(&dtd->pool);\n        /* Don't suppress the default handler if we fell through from\n         * the XML_ROLE_DOCTYPE_SYSTEM_ID case.\n         */\n        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_ENTITY_COMPLETE:\n#if XML_GE == 0\n      // This will store \"&amp;entity123;\" in entity->textPtr\n      // to end up as \"&entity123;\" in the handler.\n      if (parser->m_declEntity != NULL) {\n        const enum XML_Error result\n            = storeSelfEntityValue(parser, parser->m_declEntity);\n        if (result != XML_ERROR_NONE)\n          return result;\n      }\n#endif\n      if (dtd->keepProcessing && parser->m_declEntity\n          && parser->m_entityDeclHandler) {\n        *eventEndPP = s;\n        parser->m_entityDeclHandler(\n            parser->m_handlerArg, parser->m_declEntity->name,\n            parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,\n            parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_ENTITY_NOTATION_NAME:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        parser->m_declEntity->notation\n            = poolStoreString(&dtd->pool, enc, s, next);\n        if (! parser->m_declEntity->notation)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&dtd->pool);\n        if (parser->m_unparsedEntityDeclHandler) {\n          *eventEndPP = s;\n          parser->m_unparsedEntityDeclHandler(\n              parser->m_handlerArg, parser->m_declEntity->name,\n              parser->m_declEntity->base, parser->m_declEntity->systemId,\n              parser->m_declEntity->publicId, parser->m_declEntity->notation);\n          handleDefault = XML_FALSE;\n        } else if (parser->m_entityDeclHandler) {\n          *eventEndPP = s;\n          parser->m_entityDeclHandler(\n              parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,\n              parser->m_declEntity->base, parser->m_declEntity->systemId,\n              parser->m_declEntity->publicId, parser->m_declEntity->notation);\n          handleDefault = XML_FALSE;\n        }\n      }\n      break;\n    case XML_ROLE_GENERAL_ENTITY_NAME: {\n      if (XmlPredefinedEntityName(enc, s, next)) {\n        parser->m_declEntity = NULL;\n        break;\n      }\n      if (dtd->keepProcessing) {\n        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,\n                                                name, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_declEntity->name != name) {\n          poolDiscard(&dtd->pool);\n          parser->m_declEntity = NULL;\n        } else {\n          poolFinish(&dtd->pool);\n          parser->m_declEntity->publicId = NULL;\n          parser->m_declEntity->is_param = XML_FALSE;\n          /* if we have a parent parser or are reading an internal parameter\n             entity, then the entity declaration is not considered \"internal\"\n          */\n          parser->m_declEntity->is_internal\n              = ! (parser->m_parentParser || parser->m_openInternalEntities);\n          if (parser->m_entityDeclHandler)\n            handleDefault = XML_FALSE;\n        }\n      } else {\n        poolDiscard(&dtd->pool);\n        parser->m_declEntity = NULL;\n      }\n    } break;\n    case XML_ROLE_PARAM_ENTITY_NAME:\n#ifdef XML_DTD\n      if (dtd->keepProcessing) {\n        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                                name, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_declEntity->name != name) {\n          poolDiscard(&dtd->pool);\n          parser->m_declEntity = NULL;\n        } else {\n          poolFinish(&dtd->pool);\n          parser->m_declEntity->publicId = NULL;\n          parser->m_declEntity->is_param = XML_TRUE;\n          /* if we have a parent parser or are reading an internal parameter\n             entity, then the entity declaration is not considered \"internal\"\n          */\n          parser->m_declEntity->is_internal\n              = ! (parser->m_parentParser || parser->m_openInternalEntities);\n          if (parser->m_entityDeclHandler)\n            handleDefault = XML_FALSE;\n        }\n      } else {\n        poolDiscard(&dtd->pool);\n        parser->m_declEntity = NULL;\n      }\n#else  /* not XML_DTD */\n      parser->m_declEntity = NULL;\n#endif /* XML_DTD */\n      break;\n    case XML_ROLE_NOTATION_NAME:\n      parser->m_declNotationPublicId = NULL;\n      parser->m_declNotationName = NULL;\n      if (parser->m_notationDeclHandler) {\n        parser->m_declNotationName\n            = poolStoreString(&parser->m_tempPool, enc, s, next);\n        if (! parser->m_declNotationName)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_NOTATION_PUBLIC_ID:\n      if (! XmlIsPublicId(enc, s, next, eventPP))\n        return XML_ERROR_PUBLICID;\n      if (parser\n              ->m_declNotationName) { /* means m_notationDeclHandler != NULL */\n        XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,\n                                        s + enc->minBytesPerChar,\n                                        next - enc->minBytesPerChar);\n        if (! tem)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(tem);\n        parser->m_declNotationPublicId = tem;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_NOTATION_SYSTEM_ID:\n      if (parser->m_declNotationName && parser->m_notationDeclHandler) {\n        const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,\n                                                   s + enc->minBytesPerChar,\n                                                   next - enc->minBytesPerChar);\n        if (! systemId)\n          return XML_ERROR_NO_MEMORY;\n        *eventEndPP = s;\n        parser->m_notationDeclHandler(\n            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,\n            systemId, parser->m_declNotationPublicId);\n        handleDefault = XML_FALSE;\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_NOTATION_NO_SYSTEM_ID:\n      if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {\n        *eventEndPP = s;\n        parser->m_notationDeclHandler(\n            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,\n            0, parser->m_declNotationPublicId);\n        handleDefault = XML_FALSE;\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_ERROR:\n      switch (tok) {\n      case XML_TOK_PARAM_ENTITY_REF:\n        /* PE references in internal subset are\n           not allowed within declarations. */\n        return XML_ERROR_PARAM_ENTITY_REF;\n      case XML_TOK_XML_DECL:\n        return XML_ERROR_MISPLACED_XML_PI;\n      default:\n        return XML_ERROR_SYNTAX;\n      }\n#ifdef XML_DTD\n    case XML_ROLE_IGNORE_SECT: {\n      enum XML_Error result;\n      if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      handleDefault = XML_FALSE;\n      result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);\n      if (result != XML_ERROR_NONE)\n        return result;\n      else if (! next) {\n        parser->m_processor = ignoreSectionProcessor;\n        return result;\n      }\n    } break;\n#endif /* XML_DTD */\n    case XML_ROLE_GROUP_OPEN:\n      if (parser->m_prologState.level >= parser->m_groupSize) {\n        if (parser->m_groupSize) {\n          {\n            /* Detect and prevent integer overflow */\n            if (parser->m_groupSize > (unsigned int)(-1) / 2u) {\n              return XML_ERROR_NO_MEMORY;\n            }\n\n            char *const new_connector = REALLOC(\n                parser, parser->m_groupConnector, parser->m_groupSize *= 2);\n            if (new_connector == NULL) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n            parser->m_groupConnector = new_connector;\n          }\n\n          if (dtd->scaffIndex) {\n            /* Detect and prevent integer overflow.\n             * The preprocessor guard addresses the \"always false\" warning\n             * from -Wtype-limits on platforms where\n             * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n            if (parser->m_groupSize > SIZE_MAX / sizeof(int)) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n#endif\n\n            int *const new_scaff_index = REALLOC(\n                parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));\n            if (new_scaff_index == NULL) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n            dtd->scaffIndex = new_scaff_index;\n          }\n        } else {\n          parser->m_groupConnector = MALLOC(parser, parser->m_groupSize = 32);\n          if (! parser->m_groupConnector) {\n            parser->m_groupSize = 0;\n            return XML_ERROR_NO_MEMORY;\n          }\n        }\n      }\n      parser->m_groupConnector[parser->m_prologState.level] = 0;\n      if (dtd->in_eldecl) {\n        int myindex = nextScaffoldPart(parser);\n        if (myindex < 0)\n          return XML_ERROR_NO_MEMORY;\n        assert(dtd->scaffIndex != NULL);\n        dtd->scaffIndex[dtd->scaffLevel] = myindex;\n        dtd->scaffLevel++;\n        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_GROUP_SEQUENCE:\n      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)\n        return XML_ERROR_SYNTAX;\n      parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;\n      if (dtd->in_eldecl && parser->m_elementDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_GROUP_CHOICE:\n      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)\n        return XML_ERROR_SYNTAX;\n      if (dtd->in_eldecl\n          && ! parser->m_groupConnector[parser->m_prologState.level]\n          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n              != XML_CTYPE_MIXED)) {\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n            = XML_CTYPE_CHOICE;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;\n      break;\n    case XML_ROLE_PARAM_ENTITY_REF:\n#ifdef XML_DTD\n    case XML_ROLE_INNER_PARAM_ENTITY_REF:\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (! parser->m_paramEntityParsing)\n        dtd->keepProcessing = dtd->standalone;\n      else {\n        const XML_Char *name;\n        ENTITY *entity;\n        name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                               next - enc->minBytesPerChar);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);\n        poolDiscard(&dtd->pool);\n        /* first, determine if a check for an existing declaration is needed;\n           if yes, check that the entity exists, and that it is internal,\n           otherwise call the skipped entity handler\n        */\n        if (parser->m_prologState.documentEntity\n            && (dtd->standalone ? ! parser->m_openInternalEntities\n                                : ! dtd->hasParamEntityRefs)) {\n          if (! entity)\n            return XML_ERROR_UNDEFINED_ENTITY;\n          else if (! entity->is_internal) {\n            /* It's hard to exhaustively search the code to be sure,\n             * but there doesn't seem to be a way of executing the\n             * following line.  There are two cases:\n             *\n             * If 'standalone' is false, the DTD must have no\n             * parameter entities or we wouldn't have passed the outer\n             * 'if' statement.  That means the only entity in the hash\n             * table is the external subset name \"#\" which cannot be\n             * given as a parameter entity name in XML syntax, so the\n             * lookup must have returned NULL and we don't even reach\n             * the test for an internal entity.\n             *\n             * If 'standalone' is true, it does not seem to be\n             * possible to create entities taking this code path that\n             * are not internal entities, so fail the test above.\n             *\n             * Because this analysis is very uncertain, the code is\n             * being left in place and merely removed from the\n             * coverage test statistics.\n             */\n            return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */\n          }\n        } else if (! entity) {\n          dtd->keepProcessing = dtd->standalone;\n          /* cannot report skipped entities in declarations */\n          if ((role == XML_ROLE_PARAM_ENTITY_REF)\n              && parser->m_skippedEntityHandler) {\n            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);\n            handleDefault = XML_FALSE;\n          }\n          break;\n        }\n        if (entity->open)\n          return XML_ERROR_RECURSIVE_ENTITY_REF;\n        if (entity->textPtr) {\n          enum XML_Error result;\n          XML_Bool betweenDecl\n              = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);\n          result = processEntity(parser, entity, betweenDecl, ENTITY_INTERNAL);\n          if (result != XML_ERROR_NONE)\n            return result;\n          handleDefault = XML_FALSE;\n          break;\n        }\n        if (parser->m_externalEntityRefHandler) {\n          dtd->paramEntityRead = XML_FALSE;\n          entity->open = XML_TRUE;\n          entityTrackingOnOpen(parser, entity, __LINE__);\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId)) {\n            entityTrackingOnClose(parser, entity, __LINE__);\n            entity->open = XML_FALSE;\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          }\n          entityTrackingOnClose(parser, entity, __LINE__);\n          entity->open = XML_FALSE;\n          handleDefault = XML_FALSE;\n          if (! dtd->paramEntityRead) {\n            dtd->keepProcessing = dtd->standalone;\n            break;\n          }\n        } else {\n          dtd->keepProcessing = dtd->standalone;\n          break;\n        }\n      }\n#endif /* XML_DTD */\n      if (! dtd->standalone && parser->m_notStandaloneHandler\n          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n        return XML_ERROR_NOT_STANDALONE;\n      break;\n\n      /* Element declaration stuff */\n\n    case XML_ROLE_ELEMENT_NAME:\n      if (parser->m_elementDeclHandler) {\n        parser->m_declElementType = getElementType(parser, enc, s, next);\n        if (! parser->m_declElementType)\n          return XML_ERROR_NO_MEMORY;\n        dtd->scaffLevel = 0;\n        dtd->scaffCount = 0;\n        dtd->in_eldecl = XML_TRUE;\n        handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_ANY:\n    case XML_ROLE_CONTENT_EMPTY:\n      if (dtd->in_eldecl) {\n        if (parser->m_elementDeclHandler) {\n          // NOTE: We are avoiding MALLOC(..) here to so that\n          //       applications that are not using XML_FreeContentModel but\n          //       plain free(..) or .free_fcn() to free the content model's\n          //       memory are safe.\n          XML_Content *content = parser->m_mem.malloc_fcn(sizeof(XML_Content));\n          if (! content)\n            return XML_ERROR_NO_MEMORY;\n          content->quant = XML_CQUANT_NONE;\n          content->name = NULL;\n          content->numchildren = 0;\n          content->children = NULL;\n          content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY\n                                                          : XML_CTYPE_EMPTY);\n          *eventEndPP = s;\n          parser->m_elementDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name, content);\n          handleDefault = XML_FALSE;\n        }\n        dtd->in_eldecl = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_PCDATA:\n      if (dtd->in_eldecl) {\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n            = XML_CTYPE_MIXED;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_ELEMENT:\n      quant = XML_CQUANT_NONE;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_OPT:\n      quant = XML_CQUANT_OPT;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_REP:\n      quant = XML_CQUANT_REP;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_PLUS:\n      quant = XML_CQUANT_PLUS;\n    elementContent:\n      if (dtd->in_eldecl) {\n        ELEMENT_TYPE *el;\n        const XML_Char *name;\n        size_t nameLen;\n        const char *nxt\n            = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);\n        int myindex = nextScaffoldPart(parser);\n        if (myindex < 0)\n          return XML_ERROR_NO_MEMORY;\n        dtd->scaffold[myindex].type = XML_CTYPE_NAME;\n        dtd->scaffold[myindex].quant = quant;\n        el = getElementType(parser, enc, s, nxt);\n        if (! el)\n          return XML_ERROR_NO_MEMORY;\n        name = el->name;\n        dtd->scaffold[myindex].name = name;\n        nameLen = 0;\n        while (name[nameLen++])\n          ;\n\n        /* Detect and prevent integer overflow */\n        if (nameLen > UINT_MAX - dtd->contentStringLen) {\n          return XML_ERROR_NO_MEMORY;\n        }\n\n        dtd->contentStringLen += (unsigned)nameLen;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_GROUP_CLOSE:\n      quant = XML_CQUANT_NONE;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_OPT:\n      quant = XML_CQUANT_OPT;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_REP:\n      quant = XML_CQUANT_REP;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_PLUS:\n      quant = XML_CQUANT_PLUS;\n    closeGroup:\n      if (dtd->in_eldecl) {\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n        dtd->scaffLevel--;\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;\n        if (dtd->scaffLevel == 0) {\n          if (! handleDefault) {\n            XML_Content *model = build_model(parser);\n            if (! model)\n              return XML_ERROR_NO_MEMORY;\n            *eventEndPP = s;\n            parser->m_elementDeclHandler(\n                parser->m_handlerArg, parser->m_declElementType->name, model);\n          }\n          dtd->in_eldecl = XML_FALSE;\n          dtd->contentStringLen = 0;\n        }\n      }\n      break;\n      /* End element declaration stuff */\n\n    case XML_ROLE_PI:\n      if (! reportProcessingInstruction(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_COMMENT:\n      if (! reportComment(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_NONE:\n      switch (tok) {\n      case XML_TOK_BOM:\n        handleDefault = XML_FALSE;\n        break;\n      }\n      break;\n    case XML_ROLE_DOCTYPE_NONE:\n      if (parser->m_startDoctypeDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ENTITY_NONE:\n      if (dtd->keepProcessing && parser->m_entityDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_NOTATION_NONE:\n      if (parser->m_notationDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ATTLIST_NONE:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ELEMENT_NONE:\n      if (parser->m_elementDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    } /* end of big switch */\n\n    if (handleDefault && parser->m_defaultHandler)\n      reportDefault(parser, enc, s, next);\n\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        *nextPtr = next;\n        return XML_ERROR_NONE;\n      }\n    /* Fall through */\n    default:\n      s = next;\n      tok = XmlPrologTok(enc, s, end, &next);\n    }\n  }\n  /* not reached */\n}\n\nstatic enum XML_Error PTRCALL\nepilogProcessor(XML_Parser parser, const char *s, const char *end,\n                const char **nextPtr) {\n  parser->m_processor = epilogProcessor;\n  parser->m_eventPtr = s;\n  for (;;) {\n    const char *next = NULL;\n    int tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    parser->m_eventEndPtr = next;\n    switch (tok) {\n    /* report partial linebreak - it might be the last token */\n    case -XML_TOK_PROLOG_S:\n      if (parser->m_defaultHandler) {\n        reportDefault(parser, parser->m_encoding, s, next);\n        if (parser->m_parsingStatus.parsing == XML_FINISHED)\n          return XML_ERROR_ABORTED;\n      }\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_TOK_NONE:\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    case XML_TOK_PROLOG_S:\n      if (parser->m_defaultHandler)\n        reportDefault(parser, parser->m_encoding, s, next);\n      break;\n    case XML_TOK_PI:\n      if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_COMMENT:\n      if (! reportComment(parser, parser->m_encoding, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_INVALID:\n      parser->m_eventPtr = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (! parser->m_parsingStatus.finalBuffer) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (! parser->m_parsingStatus.finalBuffer) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    default:\n      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;\n    }\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      parser->m_eventPtr = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      parser->m_eventPtr = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n    /* Fall through */\n    default:;\n      parser->m_eventPtr = s = next;\n    }\n  }\n}\n\nstatic enum XML_Error\nprocessEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl,\n              enum EntityType type) {\n  OPEN_INTERNAL_ENTITY *openEntity, **openEntityList, **freeEntityList;\n  switch (type) {\n  case ENTITY_INTERNAL:\n    parser->m_processor = internalEntityProcessor;\n    openEntityList = &parser->m_openInternalEntities;\n    freeEntityList = &parser->m_freeInternalEntities;\n    break;\n  case ENTITY_ATTRIBUTE:\n    openEntityList = &parser->m_openAttributeEntities;\n    freeEntityList = &parser->m_freeAttributeEntities;\n    break;\n  case ENTITY_VALUE:\n    openEntityList = &parser->m_openValueEntities;\n    freeEntityList = &parser->m_freeValueEntities;\n    break;\n    /* default case serves merely as a safety net in case of a\n     * wrong entityType. Therefore we exclude the following lines\n     * from the test coverage.\n     *\n     * LCOV_EXCL_START\n     */\n  default:\n    // Should not reach here\n    assert(0);\n    /* LCOV_EXCL_STOP */\n  }\n\n  if (*freeEntityList) {\n    openEntity = *freeEntityList;\n    *freeEntityList = openEntity->next;\n  } else {\n    openEntity = MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));\n    if (! openEntity)\n      return XML_ERROR_NO_MEMORY;\n  }\n  entity->open = XML_TRUE;\n  entity->hasMore = XML_TRUE;\n#if XML_GE == 1\n  entityTrackingOnOpen(parser, entity, __LINE__);\n#endif\n  entity->processed = 0;\n  openEntity->next = *openEntityList;\n  *openEntityList = openEntity;\n  openEntity->entity = entity;\n  openEntity->type = type;\n  openEntity->startTagLevel = parser->m_tagLevel;\n  openEntity->betweenDecl = betweenDecl;\n  openEntity->internalEventPtr = NULL;\n  openEntity->internalEventEndPtr = NULL;\n\n  // Only internal entities make use of the reenter flag\n  // therefore no need to set it for other entity types\n  if (type == ENTITY_INTERNAL) {\n    triggerReenter(parser);\n  }\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error PTRCALL\ninternalEntityProcessor(XML_Parser parser, const char *s, const char *end,\n                        const char **nextPtr) {\n  UNUSED_P(s);\n  UNUSED_P(end);\n  UNUSED_P(nextPtr);\n  ENTITY *entity;\n  const char *textStart, *textEnd;\n  const char *next;\n  enum XML_Error result;\n  OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;\n  if (! openEntity)\n    return XML_ERROR_UNEXPECTED_STATE;\n\n  entity = openEntity->entity;\n\n  // This will return early\n  if (entity->hasMore) {\n    textStart = ((const char *)entity->textPtr) + entity->processed;\n    textEnd = (const char *)(entity->textPtr + entity->textLen);\n    /* Set a safe default value in case 'next' does not get set */\n    next = textStart;\n\n    if (entity->is_param) {\n      int tok\n          = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);\n      result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,\n                        tok, next, &next, XML_FALSE, XML_FALSE,\n                        XML_ACCOUNT_ENTITY_EXPANSION);\n    } else {\n      result = doContent(parser, openEntity->startTagLevel,\n                         parser->m_internalEncoding, textStart, textEnd, &next,\n                         XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION);\n    }\n\n    if (result != XML_ERROR_NONE)\n      return result;\n    // Check if entity is complete, if not, mark down how much of it is\n    // processed\n    if (textEnd != next\n        && (parser->m_parsingStatus.parsing == XML_SUSPENDED\n            || (parser->m_parsingStatus.parsing == XML_PARSING\n                && parser->m_reenter))) {\n      entity->processed = (int)(next - (const char *)entity->textPtr);\n      return result;\n    }\n\n    // Entity is complete. We cannot close it here since we need to first\n    // process its possible inner entities (which are added to the\n    // m_openInternalEntities during doProlog or doContent calls above)\n    entity->hasMore = XML_FALSE;\n    if (! entity->is_param\n        && (openEntity->startTagLevel != parser->m_tagLevel)) {\n      return XML_ERROR_ASYNC_ENTITY;\n    }\n    triggerReenter(parser);\n    return result;\n  } // End of entity processing, \"if\" block will return here\n\n  // Remove fully processed openEntity from open entity list.\n#if XML_GE == 1\n  entityTrackingOnClose(parser, entity, __LINE__);\n#endif\n  // openEntity is m_openInternalEntities' head, as we set it at the start of\n  // this function and we skipped doProlog and doContent calls with hasMore set\n  // to false. This means we can directly remove the head of\n  // m_openInternalEntities\n  assert(parser->m_openInternalEntities == openEntity);\n  entity->open = XML_FALSE;\n  parser->m_openInternalEntities = parser->m_openInternalEntities->next;\n\n  /* put openEntity back in list of free instances */\n  openEntity->next = parser->m_freeInternalEntities;\n  parser->m_freeInternalEntities = openEntity;\n\n  if (parser->m_openInternalEntities == NULL) {\n    parser->m_processor = entity->is_param ? prologProcessor : contentProcessor;\n  }\n  triggerReenter(parser);\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error PTRCALL\nerrorProcessor(XML_Parser parser, const char *s, const char *end,\n               const char **nextPtr) {\n  UNUSED_P(s);\n  UNUSED_P(end);\n  UNUSED_P(nextPtr);\n  return parser->m_errorCode;\n}\n\nstatic enum XML_Error\nstoreAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                    const char *ptr, const char *end, STRING_POOL *pool,\n                    enum XML_Account account) {\n  const char *next = ptr;\n  enum XML_Error result = XML_ERROR_NONE;\n\n  while (1) {\n    if (! parser->m_openAttributeEntities) {\n      result = appendAttributeValue(parser, enc, isCdata, next, end, pool,\n                                    account, &next);\n    } else {\n      OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openAttributeEntities;\n      if (! openEntity)\n        return XML_ERROR_UNEXPECTED_STATE;\n\n      ENTITY *const entity = openEntity->entity;\n      const char *const textStart\n          = ((const char *)entity->textPtr) + entity->processed;\n      const char *const textEnd\n          = (const char *)(entity->textPtr + entity->textLen);\n      /* Set a safe default value in case 'next' does not get set */\n      const char *nextInEntity = textStart;\n      if (entity->hasMore) {\n        result = appendAttributeValue(\n            parser, parser->m_internalEncoding, isCdata, textStart, textEnd,\n            pool, XML_ACCOUNT_ENTITY_EXPANSION, &nextInEntity);\n        if (result != XML_ERROR_NONE)\n          break;\n        // Check if entity is complete, if not, mark down how much of it is\n        // processed. A XML_SUSPENDED check here is not required as\n        // appendAttributeValue will never suspend the parser.\n        if (textEnd != nextInEntity) {\n          entity->processed\n              = (int)(nextInEntity - (const char *)entity->textPtr);\n          continue;\n        }\n\n        // Entity is complete. We cannot close it here since we need to first\n        // process its possible inner entities (which are added to the\n        // m_openAttributeEntities during appendAttributeValue)\n        entity->hasMore = XML_FALSE;\n        continue;\n      } // End of entity processing, \"if\" block skips the rest\n\n      // Remove fully processed openEntity from open entity list.\n#if XML_GE == 1\n      entityTrackingOnClose(parser, entity, __LINE__);\n#endif\n      // openEntity is m_openAttributeEntities' head, since we set it at the\n      // start of this function and because we skipped appendAttributeValue call\n      // with hasMore set to false. This means we can directly remove the head\n      // of m_openAttributeEntities\n      assert(parser->m_openAttributeEntities == openEntity);\n      entity->open = XML_FALSE;\n      parser->m_openAttributeEntities = parser->m_openAttributeEntities->next;\n\n      /* put openEntity back in list of free instances */\n      openEntity->next = parser->m_freeAttributeEntities;\n      parser->m_freeAttributeEntities = openEntity;\n    }\n\n    // Break if an error occurred or there is nothing left to process\n    if (result || (parser->m_openAttributeEntities == NULL && end == next)) {\n      break;\n    }\n  }\n\n  if (result)\n    return result;\n  if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)\n    poolChop(pool);\n  if (! poolAppendChar(pool, XML_T('\\0')))\n    return XML_ERROR_NO_MEMORY;\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error\nappendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                     const char *ptr, const char *end, STRING_POOL *pool,\n                     enum XML_Account account, const char **nextPtr) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n#ifndef XML_DTD\n  UNUSED_P(account);\n#endif\n\n  for (;;) {\n    const char *next\n        = ptr; /* XmlAttributeValueTok doesn't always set the last arg */\n    int tok = XmlAttributeValueTok(enc, ptr, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    switch (tok) {\n    case XML_TOK_NONE:\n      if (nextPtr) {\n        *nextPtr = next;\n      }\n      return XML_ERROR_NONE;\n    case XML_TOK_INVALID:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = ptr;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_CHAR_REF: {\n      XML_Char buf[XML_ENCODE_MAX];\n      int i;\n      int n = XmlCharRefNumber(enc, ptr);\n      if (n < 0) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_BAD_CHAR_REF;\n      }\n      if (! isCdata && n == 0x20 /* space */\n          && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\n        break;\n      n = XmlEncode(n, (ICHAR *)buf);\n      /* The XmlEncode() functions can never return 0 here.  That\n       * error return happens if the code point passed in is either\n       * negative or greater than or equal to 0x110000.  The\n       * XmlCharRefNumber() functions will all return a number\n       * strictly less than 0x110000 or a negative value if an error\n       * occurred.  The negative value is intercepted above, so\n       * XmlEncode() is never passed a value it might return an\n       * error for.\n       */\n      for (i = 0; i < n; i++) {\n        if (! poolAppendChar(pool, buf[i]))\n          return XML_ERROR_NO_MEMORY;\n      }\n    } break;\n    case XML_TOK_DATA_CHARS:\n      if (! poolAppend(pool, enc, ptr, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_TRAILING_CR:\n      next = ptr + enc->minBytesPerChar;\n      /* fall through */\n    case XML_TOK_ATTRIBUTE_VALUE_S:\n    case XML_TOK_DATA_NEWLINE:\n      if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\n        break;\n      if (! poolAppendChar(pool, 0x20))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_ENTITY_REF: {\n      const XML_Char *name;\n      ENTITY *entity;\n      bool checkEntityDecl;\n      XML_Char ch = (XML_Char)XmlPredefinedEntityName(\n          enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);\n      if (ch) {\n#if XML_GE == 1\n        /* NOTE: We are replacing 4-6 characters original input for 1 character\n         *       so there is no amplification and hence recording without\n         *       protection. */\n        accountingDiffTolerated(parser, tok, (char *)&ch,\n                                ((char *)&ch) + sizeof(XML_Char), __LINE__,\n                                XML_ACCOUNT_ENTITY_EXPANSION);\n#endif /* XML_GE == 1 */\n        if (! poolAppendChar(pool, ch))\n          return XML_ERROR_NO_MEMORY;\n        break;\n      }\n      name = poolStoreString(&parser->m_temp2Pool, enc,\n                             ptr + enc->minBytesPerChar,\n                             next - enc->minBytesPerChar);\n      if (! name)\n        return XML_ERROR_NO_MEMORY;\n      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);\n      poolDiscard(&parser->m_temp2Pool);\n      /* First, determine if a check for an existing declaration is needed;\n         if yes, check that the entity exists, and that it is internal.\n      */\n      if (pool == &dtd->pool) /* are we called from prolog? */\n        checkEntityDecl =\n#ifdef XML_DTD\n            parser->m_prologState.documentEntity &&\n#endif /* XML_DTD */\n            (dtd->standalone ? ! parser->m_openInternalEntities\n                             : ! dtd->hasParamEntityRefs);\n      else /* if (pool == &parser->m_tempPool): we are called from content */\n        checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;\n      if (checkEntityDecl) {\n        if (! entity)\n          return XML_ERROR_UNDEFINED_ENTITY;\n        else if (! entity->is_internal)\n          return XML_ERROR_ENTITY_DECLARED_IN_PE;\n      } else if (! entity) {\n        /* Cannot report skipped entity here - see comments on\n           parser->m_skippedEntityHandler.\n        if (parser->m_skippedEntityHandler)\n          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n        */\n        /* Cannot call the default handler because this would be\n           out of sync with the call to the startElementHandler.\n        if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)\n          reportDefault(parser, enc, ptr, next);\n        */\n        break;\n      }\n      if (entity->open) {\n        if (enc == parser->m_encoding) {\n          /* It does not appear that this line can be executed.\n           *\n           * The \"if (entity->open)\" check catches recursive entity\n           * definitions.  In order to be called with an open\n           * entity, it must have gone through this code before and\n           * been through the recursive call to\n           * appendAttributeValue() some lines below.  That call\n           * sets the local encoding (\"enc\") to the parser's\n           * internal encoding (internal_utf8 or internal_utf16),\n           * which can never be the same as the principle encoding.\n           * It doesn't appear there is another code path that gets\n           * here with entity->open being TRUE.\n           *\n           * Since it is not certain that this logic is watertight,\n           * we keep the line and merely exclude it from coverage\n           * tests.\n           */\n          parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */\n        }\n        return XML_ERROR_RECURSIVE_ENTITY_REF;\n      }\n      if (entity->notation) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_BINARY_ENTITY_REF;\n      }\n      if (! entity->textPtr) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;\n      } else {\n        enum XML_Error result;\n        result = processEntity(parser, entity, XML_FALSE, ENTITY_ATTRIBUTE);\n        if ((result == XML_ERROR_NONE) && (nextPtr != NULL)) {\n          *nextPtr = next;\n        }\n        return result;\n      }\n    } break;\n    default:\n      /* The only token returned by XmlAttributeValueTok() that does\n       * not have an explicit case here is XML_TOK_PARTIAL_CHAR.\n       * Getting that would require an entity name to contain an\n       * incomplete XML character (e.g. \\xE2\\x82); however previous\n       * tokenisers will have already recognised and rejected such\n       * names before XmlAttributeValueTok() gets a look-in.  This\n       * default case should be retained as a safety net, but the code\n       * excluded from coverage tests.\n       *\n       * LCOV_EXCL_START\n       */\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = ptr;\n      return XML_ERROR_UNEXPECTED_STATE;\n      /* LCOV_EXCL_STOP */\n    }\n    ptr = next;\n  }\n  /* not reached */\n}\n\n#if XML_GE == 1\nstatic enum XML_Error\nstoreEntityValue(XML_Parser parser, const ENCODING *enc,\n                 const char *entityTextPtr, const char *entityTextEnd,\n                 enum XML_Account account, const char **nextPtr) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  STRING_POOL *pool = &(dtd->entityValuePool);\n  enum XML_Error result = XML_ERROR_NONE;\n#  ifdef XML_DTD\n  int oldInEntityValue = parser->m_prologState.inEntityValue;\n  parser->m_prologState.inEntityValue = 1;\n#  else\n  UNUSED_P(account);\n#  endif /* XML_DTD */\n  /* never return Null for the value argument in EntityDeclHandler,\n     since this would indicate an external entity; therefore we\n     have to make sure that entityValuePool.start is not null */\n  if (! pool->blocks) {\n    if (! poolGrow(pool))\n      return XML_ERROR_NO_MEMORY;\n  }\n\n  const char *next = entityTextPtr;\n\n  /* Nothing to tokenize. */\n  if (entityTextPtr >= entityTextEnd) {\n    result = XML_ERROR_NONE;\n    goto endEntityValue;\n  }\n\n  for (;;) {\n    next\n        = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */\n    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);\n\n    if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,\n                                  account)) {\n      accountingOnAbort(parser);\n      result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      goto endEntityValue;\n    }\n\n    switch (tok) {\n    case XML_TOK_PARAM_ENTITY_REF:\n#  ifdef XML_DTD\n      if (parser->m_isParamEntity || enc != parser->m_encoding) {\n        const XML_Char *name;\n        ENTITY *entity;\n        name = poolStoreString(&parser->m_tempPool, enc,\n                               entityTextPtr + enc->minBytesPerChar,\n                               next - enc->minBytesPerChar);\n        if (! name) {\n          result = XML_ERROR_NO_MEMORY;\n          goto endEntityValue;\n        }\n        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);\n        poolDiscard(&parser->m_tempPool);\n        if (! entity) {\n          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */\n          /* cannot report skipped entity here - see comments on\n             parser->m_skippedEntityHandler\n          if (parser->m_skippedEntityHandler)\n            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n          */\n          dtd->keepProcessing = dtd->standalone;\n          goto endEntityValue;\n        }\n        if (entity->open || (entity == parser->m_declEntity)) {\n          if (enc == parser->m_encoding)\n            parser->m_eventPtr = entityTextPtr;\n          result = XML_ERROR_RECURSIVE_ENTITY_REF;\n          goto endEntityValue;\n        }\n        if (entity->systemId) {\n          if (parser->m_externalEntityRefHandler) {\n            dtd->paramEntityRead = XML_FALSE;\n            entity->open = XML_TRUE;\n            entityTrackingOnOpen(parser, entity, __LINE__);\n            if (! parser->m_externalEntityRefHandler(\n                    parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                    entity->systemId, entity->publicId)) {\n              entityTrackingOnClose(parser, entity, __LINE__);\n              entity->open = XML_FALSE;\n              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n              goto endEntityValue;\n            }\n            entityTrackingOnClose(parser, entity, __LINE__);\n            entity->open = XML_FALSE;\n            if (! dtd->paramEntityRead)\n              dtd->keepProcessing = dtd->standalone;\n          } else\n            dtd->keepProcessing = dtd->standalone;\n        } else {\n          result = processEntity(parser, entity, XML_FALSE, ENTITY_VALUE);\n          goto endEntityValue;\n        }\n        break;\n      }\n#  endif /* XML_DTD */\n      /* In the internal subset, PE references are not legal\n         within markup declarations, e.g entity values in this case. */\n      parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_PARAM_ENTITY_REF;\n      goto endEntityValue;\n    case XML_TOK_NONE:\n      result = XML_ERROR_NONE;\n      goto endEntityValue;\n    case XML_TOK_ENTITY_REF:\n    case XML_TOK_DATA_CHARS:\n      if (! poolAppend(pool, enc, entityTextPtr, next)) {\n        result = XML_ERROR_NO_MEMORY;\n        goto endEntityValue;\n      }\n      break;\n    case XML_TOK_TRAILING_CR:\n      next = entityTextPtr + enc->minBytesPerChar;\n      /* fall through */\n    case XML_TOK_DATA_NEWLINE:\n      if (pool->end == pool->ptr && ! poolGrow(pool)) {\n        result = XML_ERROR_NO_MEMORY;\n        goto endEntityValue;\n      }\n      *(pool->ptr)++ = 0xA;\n      break;\n    case XML_TOK_CHAR_REF: {\n      XML_Char buf[XML_ENCODE_MAX];\n      int i;\n      int n = XmlCharRefNumber(enc, entityTextPtr);\n      if (n < 0) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = entityTextPtr;\n        result = XML_ERROR_BAD_CHAR_REF;\n        goto endEntityValue;\n      }\n      n = XmlEncode(n, (ICHAR *)buf);\n      /* The XmlEncode() functions can never return 0 here.  That\n       * error return happens if the code point passed in is either\n       * negative or greater than or equal to 0x110000.  The\n       * XmlCharRefNumber() functions will all return a number\n       * strictly less than 0x110000 or a negative value if an error\n       * occurred.  The negative value is intercepted above, so\n       * XmlEncode() is never passed a value it might return an\n       * error for.\n       */\n      for (i = 0; i < n; i++) {\n        if (pool->end == pool->ptr && ! poolGrow(pool)) {\n          result = XML_ERROR_NO_MEMORY;\n          goto endEntityValue;\n        }\n        *(pool->ptr)++ = buf[i];\n      }\n    } break;\n    case XML_TOK_PARTIAL:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_INVALID_TOKEN;\n      goto endEntityValue;\n    case XML_TOK_INVALID:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = next;\n      result = XML_ERROR_INVALID_TOKEN;\n      goto endEntityValue;\n    default:\n      /* This default case should be unnecessary -- all the tokens\n       * that XmlEntityValueTok() can return have their own explicit\n       * cases -- but should be retained for safety.  We do however\n       * exclude it from the coverage statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_UNEXPECTED_STATE;\n      goto endEntityValue;\n      /* LCOV_EXCL_STOP */\n    }\n    entityTextPtr = next;\n  }\nendEntityValue:\n#  ifdef XML_DTD\n  parser->m_prologState.inEntityValue = oldInEntityValue;\n#  endif /* XML_DTD */\n  // If 'nextPtr' is given, it should be updated during the processing\n  if (nextPtr != NULL) {\n    *nextPtr = next;\n  }\n  return result;\n}\n\nstatic enum XML_Error\ncallStoreEntityValue(XML_Parser parser, const ENCODING *enc,\n                     const char *entityTextPtr, const char *entityTextEnd,\n                     enum XML_Account account) {\n  const char *next = entityTextPtr;\n  enum XML_Error result = XML_ERROR_NONE;\n  while (1) {\n    if (! parser->m_openValueEntities) {\n      result\n          = storeEntityValue(parser, enc, next, entityTextEnd, account, &next);\n    } else {\n      OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openValueEntities;\n      if (! openEntity)\n        return XML_ERROR_UNEXPECTED_STATE;\n\n      ENTITY *const entity = openEntity->entity;\n      const char *const textStart\n          = ((const char *)entity->textPtr) + entity->processed;\n      const char *const textEnd\n          = (const char *)(entity->textPtr + entity->textLen);\n      /* Set a safe default value in case 'next' does not get set */\n      const char *nextInEntity = textStart;\n      if (entity->hasMore) {\n        result = storeEntityValue(parser, parser->m_internalEncoding, textStart,\n                                  textEnd, XML_ACCOUNT_ENTITY_EXPANSION,\n                                  &nextInEntity);\n        if (result != XML_ERROR_NONE)\n          break;\n        // Check if entity is complete, if not, mark down how much of it is\n        // processed. A XML_SUSPENDED check here is not required as\n        // appendAttributeValue will never suspend the parser.\n        if (textEnd != nextInEntity) {\n          entity->processed\n              = (int)(nextInEntity - (const char *)entity->textPtr);\n          continue;\n        }\n\n        // Entity is complete. We cannot close it here since we need to first\n        // process its possible inner entities (which are added to the\n        // m_openValueEntities during storeEntityValue)\n        entity->hasMore = XML_FALSE;\n        continue;\n      } // End of entity processing, \"if\" block skips the rest\n\n      // Remove fully processed openEntity from open entity list.\n#  if XML_GE == 1\n      entityTrackingOnClose(parser, entity, __LINE__);\n#  endif\n      // openEntity is m_openValueEntities' head, since we set it at the\n      // start of this function and because we skipped storeEntityValue call\n      // with hasMore set to false. This means we can directly remove the head\n      // of m_openValueEntities\n      assert(parser->m_openValueEntities == openEntity);\n      entity->open = XML_FALSE;\n      parser->m_openValueEntities = parser->m_openValueEntities->next;\n\n      /* put openEntity back in list of free instances */\n      openEntity->next = parser->m_freeValueEntities;\n      parser->m_freeValueEntities = openEntity;\n    }\n\n    // Break if an error occurred or there is nothing left to process\n    if (result\n        || (parser->m_openValueEntities == NULL && entityTextEnd == next)) {\n      break;\n    }\n  }\n\n  return result;\n}\n\n#else /* XML_GE == 0 */\n\nstatic enum XML_Error\nstoreSelfEntityValue(XML_Parser parser, ENTITY *entity) {\n  // This will store \"&amp;entity123;\" in entity->textPtr\n  // to end up as \"&entity123;\" in the handler.\n  const char *const entity_start = \"&amp;\";\n  const char *const entity_end = \";\";\n\n  STRING_POOL *const pool = &(parser->m_dtd->entityValuePool);\n  if (! poolAppendString(pool, entity_start)\n      || ! poolAppendString(pool, entity->name)\n      || ! poolAppendString(pool, entity_end)) {\n    poolDiscard(pool);\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  entity->textPtr = poolStart(pool);\n  entity->textLen = (int)(poolLength(pool));\n  poolFinish(pool);\n\n  return XML_ERROR_NONE;\n}\n\n#endif /* XML_GE == 0 */\n\nstatic void FASTCALL\nnormalizeLines(XML_Char *s) {\n  XML_Char *p;\n  for (;; s++) {\n    if (*s == XML_T('\\0'))\n      return;\n    if (*s == 0xD)\n      break;\n  }\n  p = s;\n  do {\n    if (*s == 0xD) {\n      *p++ = 0xA;\n      if (*++s == 0xA)\n        s++;\n    } else\n      *p++ = *s++;\n  } while (*s);\n  *p = XML_T('\\0');\n}\n\nstatic int\nreportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\n                            const char *start, const char *end) {\n  const XML_Char *target;\n  XML_Char *data;\n  const char *tem;\n  if (! parser->m_processingInstructionHandler) {\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, start, end);\n    return 1;\n  }\n  start += enc->minBytesPerChar * 2;\n  tem = start + XmlNameLength(enc, start);\n  target = poolStoreString(&parser->m_tempPool, enc, start, tem);\n  if (! target)\n    return 0;\n  poolFinish(&parser->m_tempPool);\n  data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),\n                         end - enc->minBytesPerChar * 2);\n  if (! data)\n    return 0;\n  normalizeLines(data);\n  parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);\n  poolClear(&parser->m_tempPool);\n  return 1;\n}\n\nstatic int\nreportComment(XML_Parser parser, const ENCODING *enc, const char *start,\n              const char *end) {\n  XML_Char *data;\n  if (! parser->m_commentHandler) {\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, start, end);\n    return 1;\n  }\n  data = poolStoreString(&parser->m_tempPool, enc,\n                         start + enc->minBytesPerChar * 4,\n                         end - enc->minBytesPerChar * 3);\n  if (! data)\n    return 0;\n  normalizeLines(data);\n  parser->m_commentHandler(parser->m_handlerArg, data);\n  poolClear(&parser->m_tempPool);\n  return 1;\n}\n\nstatic void\nreportDefault(XML_Parser parser, const ENCODING *enc, const char *s,\n              const char *end) {\n  if (MUST_CONVERT(enc, s)) {\n    enum XML_Convert_Result convert_res;\n    const char **eventPP;\n    const char **eventEndPP;\n    if (enc == parser->m_encoding) {\n      eventPP = &parser->m_eventPtr;\n      eventEndPP = &parser->m_eventEndPtr;\n    } else {\n      /* To get here, two things must be true; the parser must be\n       * using a character encoding that is not the same as the\n       * encoding passed in, and the encoding passed in must need\n       * conversion to the internal format (UTF-8 unless XML_UNICODE\n       * is defined).  The only occasions on which the encoding passed\n       * in is not the same as the parser's encoding are when it is\n       * the internal encoding (e.g. a previously defined parameter\n       * entity, already converted to internal format).  This by\n       * definition doesn't need conversion, so the whole branch never\n       * gets executed.\n       *\n       * For safety's sake we don't delete these lines and merely\n       * exclude them from coverage statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n      eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n      /* LCOV_EXCL_STOP */\n    }\n    do {\n      ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n      convert_res\n          = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n      *eventEndPP = s;\n      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,\n                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n      *eventPP = s;\n    } while ((convert_res != XML_CONVERT_COMPLETED)\n             && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));\n  } else\n    parser->m_defaultHandler(\n        parser->m_handlerArg, (const XML_Char *)s,\n        (int)((const XML_Char *)end - (const XML_Char *)s));\n}\n\nstatic int\ndefineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n                XML_Bool isId, const XML_Char *value, XML_Parser parser) {\n  DEFAULT_ATTRIBUTE *att;\n  if (value || isId) {\n    /* The handling of default attributes gets messed up if we have\n       a default which duplicates a non-default. */\n    int i;\n    for (i = 0; i < type->nDefaultAtts; i++)\n      if (attId == type->defaultAtts[i].id)\n        return 1;\n    if (isId && ! type->idAtt && ! attId->xmlns)\n      type->idAtt = attId;\n  }\n  if (type->nDefaultAtts == type->allocDefaultAtts) {\n    if (type->allocDefaultAtts == 0) {\n      type->allocDefaultAtts = 8;\n      type->defaultAtts\n          = MALLOC(parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));\n      if (! type->defaultAtts) {\n        type->allocDefaultAtts = 0;\n        return 0;\n      }\n    } else {\n      DEFAULT_ATTRIBUTE *temp;\n\n      /* Detect and prevent integer overflow */\n      if (type->allocDefaultAtts > INT_MAX / 2) {\n        return 0;\n      }\n\n      int count = type->allocDefaultAtts * 2;\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((unsigned)count > SIZE_MAX / sizeof(DEFAULT_ATTRIBUTE)) {\n        return 0;\n      }\n#endif\n\n      temp = REALLOC(parser, type->defaultAtts,\n                     (count * sizeof(DEFAULT_ATTRIBUTE)));\n      if (temp == NULL)\n        return 0;\n      type->allocDefaultAtts = count;\n      type->defaultAtts = temp;\n    }\n  }\n  att = type->defaultAtts + type->nDefaultAtts;\n  att->id = attId;\n  att->value = value;\n  att->isCdata = isCdata;\n  if (! isCdata)\n    attId->maybeTokenized = XML_TRUE;\n  type->nDefaultAtts += 1;\n  return 1;\n}\n\nstatic int\nsetElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *name;\n  for (name = elementType->name; *name; name++) {\n    if (*name == XML_T(ASCII_COLON)) {\n      PREFIX *prefix;\n      const XML_Char *s;\n      for (s = elementType->name; s != name; s++) {\n        if (! poolAppendChar(&dtd->pool, *s))\n          return 0;\n      }\n      if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n        return 0;\n      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),\n                                sizeof(PREFIX));\n      if (! prefix)\n        return 0;\n      if (prefix->name == poolStart(&dtd->pool))\n        poolFinish(&dtd->pool);\n      else\n        poolDiscard(&dtd->pool);\n      elementType->prefix = prefix;\n      break;\n    }\n  }\n  return 1;\n}\n\nstatic ATTRIBUTE_ID *\ngetAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,\n               const char *end) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  ATTRIBUTE_ID *id;\n  const XML_Char *name;\n  if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n    return NULL;\n  name = poolStoreString(&dtd->pool, enc, start, end);\n  if (! name)\n    return NULL;\n  /* skip quotation mark - its storage will be reused (like in name[-1]) */\n  ++name;\n  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,\n                              sizeof(ATTRIBUTE_ID));\n  if (! id)\n    return NULL;\n  if (id->name != name)\n    poolDiscard(&dtd->pool);\n  else {\n    poolFinish(&dtd->pool);\n    if (! parser->m_ns)\n      ;\n    else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)\n             && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)\n             && name[4] == XML_T(ASCII_s)\n             && (name[5] == XML_T('\\0') || name[5] == XML_T(ASCII_COLON))) {\n      if (name[5] == XML_T('\\0'))\n        id->prefix = &dtd->defaultPrefix;\n      else\n        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,\n                                      sizeof(PREFIX));\n      id->xmlns = XML_TRUE;\n    } else {\n      int i;\n      for (i = 0; name[i]; i++) {\n        /* attributes without prefix are *not* in the default namespace */\n        if (name[i] == XML_T(ASCII_COLON)) {\n          int j;\n          for (j = 0; j < i; j++) {\n            if (! poolAppendChar(&dtd->pool, name[j]))\n              return NULL;\n          }\n          if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n            return NULL;\n          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,\n                                        poolStart(&dtd->pool), sizeof(PREFIX));\n          if (! id->prefix)\n            return NULL;\n          if (id->prefix->name == poolStart(&dtd->pool))\n            poolFinish(&dtd->pool);\n          else\n            poolDiscard(&dtd->pool);\n          break;\n        }\n      }\n    }\n  }\n  return id;\n}\n\n#define CONTEXT_SEP XML_T(ASCII_FF)\n\nstatic const XML_Char *\ngetContext(XML_Parser parser) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  HASH_TABLE_ITER iter;\n  XML_Bool needSep = XML_FALSE;\n\n  if (dtd->defaultPrefix.binding) {\n    int i;\n    int len;\n    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))\n      return NULL;\n    len = dtd->defaultPrefix.binding->uriLen;\n    if (parser->m_namespaceSeparator)\n      len--;\n    for (i = 0; i < len; i++) {\n      if (! poolAppendChar(&parser->m_tempPool,\n                           dtd->defaultPrefix.binding->uri[i])) {\n        /* Because of memory caching, I don't believe this line can be\n         * executed.\n         *\n         * This is part of a loop copying the default prefix binding\n         * URI into the parser's temporary string pool.  Previously,\n         * that URI was copied into the same string pool, with a\n         * terminating NUL character, as part of setContext().  When\n         * the pool was cleared, that leaves a block definitely big\n         * enough to hold the URI on the free block list of the pool.\n         * The URI copy in getContext() therefore cannot run out of\n         * memory.\n         *\n         * If the pool is used between the setContext() and\n         * getContext() calls, the worst it can do is leave a bigger\n         * block on the front of the free list.  Given that this is\n         * all somewhat inobvious and program logic can be changed, we\n         * don't delete the line but we do exclude it from the test\n         * coverage statistics.\n         */\n        return NULL; /* LCOV_EXCL_LINE */\n      }\n    }\n    needSep = XML_TRUE;\n  }\n\n  hashTableIterInit(&iter, &(dtd->prefixes));\n  for (;;) {\n    int i;\n    int len;\n    const XML_Char *s;\n    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);\n    if (! prefix)\n      break;\n    if (! prefix->binding) {\n      /* This test appears to be (justifiable) paranoia.  There does\n       * not seem to be a way of injecting a prefix without a binding\n       * that doesn't get errored long before this function is called.\n       * The test should remain for safety's sake, so we instead\n       * exclude the following line from the coverage statistics.\n       */\n      continue; /* LCOV_EXCL_LINE */\n    }\n    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))\n      return NULL;\n    for (s = prefix->name; *s; s++)\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return NULL;\n    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))\n      return NULL;\n    len = prefix->binding->uriLen;\n    if (parser->m_namespaceSeparator)\n      len--;\n    for (i = 0; i < len; i++)\n      if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))\n        return NULL;\n    needSep = XML_TRUE;\n  }\n\n  hashTableIterInit(&iter, &(dtd->generalEntities));\n  for (;;) {\n    const XML_Char *s;\n    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (! e->open)\n      continue;\n    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))\n      return NULL;\n    for (s = e->name; *s; s++)\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return 0;\n    needSep = XML_TRUE;\n  }\n\n  if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n    return NULL;\n  return parser->m_tempPool.start;\n}\n\nstatic XML_Bool\nsetContext(XML_Parser parser, const XML_Char *context) {\n  if (context == NULL) {\n    return XML_FALSE;\n  }\n\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *s = context;\n\n  while (*context != XML_T('\\0')) {\n    if (*s == CONTEXT_SEP || *s == XML_T('\\0')) {\n      ENTITY *e;\n      if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n        return XML_FALSE;\n      e = (ENTITY *)lookup(parser, &dtd->generalEntities,\n                           poolStart(&parser->m_tempPool), 0);\n      if (e)\n        e->open = XML_TRUE;\n      if (*s != XML_T('\\0'))\n        s++;\n      context = s;\n      poolDiscard(&parser->m_tempPool);\n    } else if (*s == XML_T(ASCII_EQUALS)) {\n      PREFIX *prefix;\n      if (poolLength(&parser->m_tempPool) == 0)\n        prefix = &dtd->defaultPrefix;\n      else {\n        if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n          return XML_FALSE;\n        const XML_Char *const prefixName = poolCopyStringNoFinish(\n            &dtd->pool, poolStart(&parser->m_tempPool));\n        if (! prefixName) {\n          return XML_FALSE;\n        }\n\n        prefix = (PREFIX *)lookup(parser, &dtd->prefixes, prefixName,\n                                  sizeof(PREFIX));\n\n        const bool prefixNameUsed = prefix && prefix->name == prefixName;\n        if (prefixNameUsed)\n          poolFinish(&dtd->pool);\n        else\n          poolDiscard(&dtd->pool);\n\n        if (! prefix)\n          return XML_FALSE;\n\n        poolDiscard(&parser->m_tempPool);\n      }\n      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\\0');\n           context++)\n        if (! poolAppendChar(&parser->m_tempPool, *context))\n          return XML_FALSE;\n      if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n        return XML_FALSE;\n      if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),\n                     &parser->m_inheritedBindings)\n          != XML_ERROR_NONE)\n        return XML_FALSE;\n      poolDiscard(&parser->m_tempPool);\n      if (*context != XML_T('\\0'))\n        ++context;\n      s = context;\n    } else {\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return XML_FALSE;\n      s++;\n    }\n  }\n  return XML_TRUE;\n}\n\nstatic void FASTCALL\nnormalizePublicId(XML_Char *publicId) {\n  XML_Char *p = publicId;\n  XML_Char *s;\n  for (s = publicId; *s; s++) {\n    switch (*s) {\n    case 0x20:\n    case 0xD:\n    case 0xA:\n      if (p != publicId && p[-1] != 0x20)\n        *p++ = 0x20;\n      break;\n    default:\n      *p++ = *s;\n    }\n  }\n  if (p != publicId && p[-1] == 0x20)\n    --p;\n  *p = XML_T('\\0');\n}\n\nstatic DTD *\ndtdCreate(XML_Parser parser) {\n  DTD *p = MALLOC(parser, sizeof(DTD));\n  if (p == NULL)\n    return p;\n  poolInit(&(p->pool), parser);\n  poolInit(&(p->entityValuePool), parser);\n  hashTableInit(&(p->generalEntities), parser);\n  hashTableInit(&(p->elementTypes), parser);\n  hashTableInit(&(p->attributeIds), parser);\n  hashTableInit(&(p->prefixes), parser);\n#ifdef XML_DTD\n  p->paramEntityRead = XML_FALSE;\n  hashTableInit(&(p->paramEntities), parser);\n#endif /* XML_DTD */\n  p->defaultPrefix.name = NULL;\n  p->defaultPrefix.binding = NULL;\n\n  p->in_eldecl = XML_FALSE;\n  p->scaffIndex = NULL;\n  p->scaffold = NULL;\n  p->scaffLevel = 0;\n  p->scaffSize = 0;\n  p->scaffCount = 0;\n  p->contentStringLen = 0;\n\n  p->keepProcessing = XML_TRUE;\n  p->hasParamEntityRefs = XML_FALSE;\n  p->standalone = XML_FALSE;\n  return p;\n}\n\nstatic void\ndtdReset(DTD *p, XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n  hashTableIterInit(&iter, &(p->elementTypes));\n  for (;;) {\n    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (e->allocDefaultAtts != 0)\n      FREE(parser, e->defaultAtts);\n  }\n  hashTableClear(&(p->generalEntities));\n#ifdef XML_DTD\n  p->paramEntityRead = XML_FALSE;\n  hashTableClear(&(p->paramEntities));\n#endif /* XML_DTD */\n  hashTableClear(&(p->elementTypes));\n  hashTableClear(&(p->attributeIds));\n  hashTableClear(&(p->prefixes));\n  poolClear(&(p->pool));\n  poolClear(&(p->entityValuePool));\n  p->defaultPrefix.name = NULL;\n  p->defaultPrefix.binding = NULL;\n\n  p->in_eldecl = XML_FALSE;\n\n  FREE(parser, p->scaffIndex);\n  p->scaffIndex = NULL;\n  FREE(parser, p->scaffold);\n  p->scaffold = NULL;\n\n  p->scaffLevel = 0;\n  p->scaffSize = 0;\n  p->scaffCount = 0;\n  p->contentStringLen = 0;\n\n  p->keepProcessing = XML_TRUE;\n  p->hasParamEntityRefs = XML_FALSE;\n  p->standalone = XML_FALSE;\n}\n\nstatic void\ndtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n  hashTableIterInit(&iter, &(p->elementTypes));\n  for (;;) {\n    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (e->allocDefaultAtts != 0)\n      FREE(parser, e->defaultAtts);\n  }\n  hashTableDestroy(&(p->generalEntities));\n#ifdef XML_DTD\n  hashTableDestroy(&(p->paramEntities));\n#endif /* XML_DTD */\n  hashTableDestroy(&(p->elementTypes));\n  hashTableDestroy(&(p->attributeIds));\n  hashTableDestroy(&(p->prefixes));\n  poolDestroy(&(p->pool));\n  poolDestroy(&(p->entityValuePool));\n  if (isDocEntity) {\n    FREE(parser, p->scaffIndex);\n    FREE(parser, p->scaffold);\n  }\n  FREE(parser, p);\n}\n\n/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.\n   The new DTD has already been initialized.\n*/\nstatic int\ndtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n        XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n\n  /* Copy the prefix table. */\n\n  hashTableIterInit(&iter, &(oldDtd->prefixes));\n  for (;;) {\n    const XML_Char *name;\n    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);\n    if (! oldP)\n      break;\n    name = poolCopyString(&(newDtd->pool), oldP->name);\n    if (! name)\n      return 0;\n    if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))\n      return 0;\n  }\n\n  hashTableIterInit(&iter, &(oldDtd->attributeIds));\n\n  /* Copy the attribute id table. */\n\n  for (;;) {\n    ATTRIBUTE_ID *newA;\n    const XML_Char *name;\n    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);\n\n    if (! oldA)\n      break;\n    /* Remember to allocate the scratch byte before the name. */\n    if (! poolAppendChar(&(newDtd->pool), XML_T('\\0')))\n      return 0;\n    name = poolCopyString(&(newDtd->pool), oldA->name);\n    if (! name)\n      return 0;\n    ++name;\n    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,\n                                  sizeof(ATTRIBUTE_ID));\n    if (! newA)\n      return 0;\n    newA->maybeTokenized = oldA->maybeTokenized;\n    if (oldA->prefix) {\n      newA->xmlns = oldA->xmlns;\n      if (oldA->prefix == &oldDtd->defaultPrefix)\n        newA->prefix = &newDtd->defaultPrefix;\n      else\n        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                        oldA->prefix->name, 0);\n    }\n  }\n\n  /* Copy the element type table. */\n\n  hashTableIterInit(&iter, &(oldDtd->elementTypes));\n\n  for (;;) {\n    int i;\n    ELEMENT_TYPE *newE;\n    const XML_Char *name;\n    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! oldE)\n      break;\n    name = poolCopyString(&(newDtd->pool), oldE->name);\n    if (! name)\n      return 0;\n    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,\n                                  sizeof(ELEMENT_TYPE));\n    if (! newE)\n      return 0;\n    if (oldE->nDefaultAtts) {\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((size_t)oldE->nDefaultAtts > SIZE_MAX / sizeof(DEFAULT_ATTRIBUTE)) {\n        return 0;\n      }\n#endif\n      newE->defaultAtts\n          = MALLOC(parser, oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));\n      if (! newE->defaultAtts) {\n        return 0;\n      }\n    }\n    if (oldE->idAtt)\n      newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),\n                                           oldE->idAtt->name, 0);\n    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;\n    if (oldE->prefix)\n      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                      oldE->prefix->name, 0);\n    for (i = 0; i < newE->nDefaultAtts; i++) {\n      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(\n          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);\n      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;\n      if (oldE->defaultAtts[i].value) {\n        newE->defaultAtts[i].value\n            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);\n        if (! newE->defaultAtts[i].value)\n          return 0;\n      } else\n        newE->defaultAtts[i].value = NULL;\n    }\n  }\n\n  /* Copy the entity tables. */\n  if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),\n                        &(oldDtd->generalEntities)))\n    return 0;\n\n#ifdef XML_DTD\n  if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),\n                        &(oldDtd->paramEntities)))\n    return 0;\n  newDtd->paramEntityRead = oldDtd->paramEntityRead;\n#endif /* XML_DTD */\n\n  newDtd->keepProcessing = oldDtd->keepProcessing;\n  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;\n  newDtd->standalone = oldDtd->standalone;\n\n  /* Don't want deep copying for scaffolding */\n  newDtd->in_eldecl = oldDtd->in_eldecl;\n  newDtd->scaffold = oldDtd->scaffold;\n  newDtd->contentStringLen = oldDtd->contentStringLen;\n  newDtd->scaffSize = oldDtd->scaffSize;\n  newDtd->scaffLevel = oldDtd->scaffLevel;\n  newDtd->scaffIndex = oldDtd->scaffIndex;\n\n  return 1;\n} /* End dtdCopy */\n\nstatic int\ncopyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,\n                STRING_POOL *newPool, const HASH_TABLE *oldTable) {\n  HASH_TABLE_ITER iter;\n  const XML_Char *cachedOldBase = NULL;\n  const XML_Char *cachedNewBase = NULL;\n\n  hashTableIterInit(&iter, oldTable);\n\n  for (;;) {\n    ENTITY *newE;\n    const XML_Char *name;\n    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);\n    if (! oldE)\n      break;\n    name = poolCopyString(newPool, oldE->name);\n    if (! name)\n      return 0;\n    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));\n    if (! newE)\n      return 0;\n    if (oldE->systemId) {\n      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);\n      if (! tem)\n        return 0;\n      newE->systemId = tem;\n      if (oldE->base) {\n        if (oldE->base == cachedOldBase)\n          newE->base = cachedNewBase;\n        else {\n          cachedOldBase = oldE->base;\n          tem = poolCopyString(newPool, cachedOldBase);\n          if (! tem)\n            return 0;\n          cachedNewBase = newE->base = tem;\n        }\n      }\n      if (oldE->publicId) {\n        tem = poolCopyString(newPool, oldE->publicId);\n        if (! tem)\n          return 0;\n        newE->publicId = tem;\n      }\n    } else {\n      const XML_Char *tem\n          = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);\n      if (! tem)\n        return 0;\n      newE->textPtr = tem;\n      newE->textLen = oldE->textLen;\n    }\n    if (oldE->notation) {\n      const XML_Char *tem = poolCopyString(newPool, oldE->notation);\n      if (! tem)\n        return 0;\n      newE->notation = tem;\n    }\n    newE->is_param = oldE->is_param;\n    newE->is_internal = oldE->is_internal;\n  }\n  return 1;\n}\n\n#define INIT_POWER 6\n\nstatic XML_Bool FASTCALL\nkeyeq(KEY s1, KEY s2) {\n  for (; *s1 == *s2; s1++, s2++)\n    if (*s1 == 0)\n      return XML_TRUE;\n  return XML_FALSE;\n}\n\nstatic size_t\nkeylen(KEY s) {\n  size_t len = 0;\n  for (; *s; s++, len++)\n    ;\n  return len;\n}\n\nstatic void\ncopy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  *key = rootParser->m_hash_secret_salt_128;\n}\n\nstatic unsigned long FASTCALL\nhash(XML_Parser parser, KEY s) {\n  struct siphash state;\n  struct sipkey key;\n  (void)sip24_valid;\n  copy_salt_to_sipkey(parser, &key);\n  sip24_init(&state, &key);\n  sip24_update(&state, s, keylen(s) * sizeof(XML_Char));\n  return (unsigned long)sip24_final(&state);\n}\n\nstatic NAMED *\nlookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {\n  size_t i;\n  if (table->size == 0) {\n    size_t tsize;\n    if (! createSize)\n      return NULL;\n    table->power = INIT_POWER;\n    /* table->size is a power of 2 */\n    table->size = (size_t)1 << INIT_POWER;\n    tsize = table->size * sizeof(NAMED *);\n    table->v = MALLOC(table->parser, tsize);\n    if (! table->v) {\n      table->size = 0;\n      return NULL;\n    }\n    memset(table->v, 0, tsize);\n    i = hash(parser, name) & ((unsigned long)table->size - 1);\n  } else {\n    unsigned long h = hash(parser, name);\n    unsigned long mask = (unsigned long)table->size - 1;\n    unsigned char step = 0;\n    i = h & mask;\n    while (table->v[i]) {\n      if (keyeq(name, table->v[i]->name))\n        return table->v[i];\n      if (! step)\n        step = PROBE_STEP(h, mask, table->power);\n      i < step ? (i += table->size - step) : (i -= step);\n    }\n    if (! createSize)\n      return NULL;\n\n    /* check for overflow (table is half full) */\n    if (table->used >> (table->power - 1)) {\n      unsigned char newPower = table->power + 1;\n\n      /* Detect and prevent invalid shift */\n      if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {\n        return NULL;\n      }\n\n      size_t newSize = (size_t)1 << newPower;\n      unsigned long newMask = (unsigned long)newSize - 1;\n\n      /* Detect and prevent integer overflow */\n      if (newSize > SIZE_MAX / sizeof(NAMED *)) {\n        return NULL;\n      }\n\n      size_t tsize = newSize * sizeof(NAMED *);\n      NAMED **newV = MALLOC(table->parser, tsize);\n      if (! newV)\n        return NULL;\n      memset(newV, 0, tsize);\n      for (i = 0; i < table->size; i++)\n        if (table->v[i]) {\n          unsigned long newHash = hash(parser, table->v[i]->name);\n          size_t j = newHash & newMask;\n          step = 0;\n          while (newV[j]) {\n            if (! step)\n              step = PROBE_STEP(newHash, newMask, newPower);\n            j < step ? (j += newSize - step) : (j -= step);\n          }\n          newV[j] = table->v[i];\n        }\n      FREE(table->parser, table->v);\n      table->v = newV;\n      table->power = newPower;\n      table->size = newSize;\n      i = h & newMask;\n      step = 0;\n      while (table->v[i]) {\n        if (! step)\n          step = PROBE_STEP(h, newMask, newPower);\n        i < step ? (i += newSize - step) : (i -= step);\n      }\n    }\n  }\n  table->v[i] = MALLOC(table->parser, createSize);\n  if (! table->v[i])\n    return NULL;\n  memset(table->v[i], 0, createSize);\n  table->v[i]->name = name;\n  (table->used)++;\n  return table->v[i];\n}\n\nstatic void FASTCALL\nhashTableClear(HASH_TABLE *table) {\n  size_t i;\n  for (i = 0; i < table->size; i++) {\n    FREE(table->parser, table->v[i]);\n    table->v[i] = NULL;\n  }\n  table->used = 0;\n}\n\nstatic void FASTCALL\nhashTableDestroy(HASH_TABLE *table) {\n  size_t i;\n  for (i = 0; i < table->size; i++)\n    FREE(table->parser, table->v[i]);\n  FREE(table->parser, table->v);\n}\n\nstatic void FASTCALL\nhashTableInit(HASH_TABLE *p, XML_Parser parser) {\n  p->power = 0;\n  p->size = 0;\n  p->used = 0;\n  p->v = NULL;\n  p->parser = parser;\n}\n\nstatic void FASTCALL\nhashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {\n  iter->p = table->v;\n  iter->end = iter->p ? iter->p + table->size : NULL;\n}\n\nstatic NAMED *FASTCALL\nhashTableIterNext(HASH_TABLE_ITER *iter) {\n  while (iter->p != iter->end) {\n    NAMED *tem = *(iter->p)++;\n    if (tem)\n      return tem;\n  }\n  return NULL;\n}\n\nstatic void FASTCALL\npoolInit(STRING_POOL *pool, XML_Parser parser) {\n  pool->blocks = NULL;\n  pool->freeBlocks = NULL;\n  pool->start = NULL;\n  pool->ptr = NULL;\n  pool->end = NULL;\n  pool->parser = parser;\n}\n\nstatic void FASTCALL\npoolClear(STRING_POOL *pool) {\n  if (! pool->freeBlocks)\n    pool->freeBlocks = pool->blocks;\n  else {\n    BLOCK *p = pool->blocks;\n    while (p) {\n      BLOCK *tem = p->next;\n      p->next = pool->freeBlocks;\n      pool->freeBlocks = p;\n      p = tem;\n    }\n  }\n  pool->blocks = NULL;\n  pool->start = NULL;\n  pool->ptr = NULL;\n  pool->end = NULL;\n}\n\nstatic void FASTCALL\npoolDestroy(STRING_POOL *pool) {\n  BLOCK *p = pool->blocks;\n  while (p) {\n    BLOCK *tem = p->next;\n    FREE(pool->parser, p);\n    p = tem;\n  }\n  p = pool->freeBlocks;\n  while (p) {\n    BLOCK *tem = p->next;\n    FREE(pool->parser, p);\n    p = tem;\n  }\n}\n\nstatic XML_Char *\npoolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,\n           const char *end) {\n  if (! pool->ptr && ! poolGrow(pool))\n    return NULL;\n  for (;;) {\n    const enum XML_Convert_Result convert_res = XmlConvert(\n        enc, &ptr, end, (ICHAR **)&(pool->ptr), (const ICHAR *)pool->end);\n    if ((convert_res == XML_CONVERT_COMPLETED)\n        || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n      break;\n    if (! poolGrow(pool))\n      return NULL;\n  }\n  return pool->start;\n}\n\nstatic const XML_Char *FASTCALL\npoolCopyString(STRING_POOL *pool, const XML_Char *s) {\n  do {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n  } while (*s++);\n  s = pool->start;\n  poolFinish(pool);\n  return s;\n}\n\n// A version of `poolCopyString` that does not call `poolFinish`\n// and reverts any partial advancement upon failure.\nstatic const XML_Char *FASTCALL\npoolCopyStringNoFinish(STRING_POOL *pool, const XML_Char *s) {\n  const XML_Char *const original = s;\n  do {\n    if (! poolAppendChar(pool, *s)) {\n      // Revert any previously successful advancement\n      const ptrdiff_t advancedBy = s - original;\n      if (advancedBy > 0)\n        pool->ptr -= advancedBy;\n      return NULL;\n    }\n  } while (*s++);\n  return pool->start;\n}\n\nstatic const XML_Char *\npoolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {\n  if (! pool->ptr && ! poolGrow(pool)) {\n    /* The following line is unreachable given the current usage of\n     * poolCopyStringN().  Currently it is called from exactly one\n     * place to copy the text of a simple general entity.  By that\n     * point, the name of the entity is already stored in the pool, so\n     * pool->ptr cannot be NULL.\n     *\n     * If poolCopyStringN() is used elsewhere as it well might be,\n     * this line may well become executable again.  Regardless, this\n     * sort of check shouldn't be removed lightly, so we just exclude\n     * it from the coverage statistics.\n     */\n    return NULL; /* LCOV_EXCL_LINE */\n  }\n  for (; n > 0; --n, s++) {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n  }\n  s = pool->start;\n  poolFinish(pool);\n  return s;\n}\n\nstatic const XML_Char *FASTCALL\npoolAppendString(STRING_POOL *pool, const XML_Char *s) {\n  while (*s) {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n    s++;\n  }\n  return pool->start;\n}\n\nstatic XML_Char *\npoolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,\n                const char *end) {\n  if (! poolAppend(pool, enc, ptr, end))\n    return NULL;\n  if (pool->ptr == pool->end && ! poolGrow(pool))\n    return NULL;\n  *(pool->ptr)++ = 0;\n  return pool->start;\n}\n\nstatic size_t\npoolBytesToAllocateFor(int blockSize) {\n  /* Unprotected math would be:\n  ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);\n  **\n  ** Detect overflow, avoiding _signed_ overflow undefined behavior\n  ** For a + b * c we check b * c in isolation first, so that addition of a\n  ** on top has no chance of making us accept a small non-negative number\n  */\n  const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */\n\n  if (blockSize <= 0)\n    return 0;\n\n  if (blockSize > (int)(INT_MAX / stretch))\n    return 0;\n\n  {\n    const int stretchedBlockSize = blockSize * (int)stretch;\n    const int bytesToAllocate\n        = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);\n    if (bytesToAllocate < 0)\n      return 0;\n\n    return (size_t)bytesToAllocate;\n  }\n}\n\nstatic XML_Bool FASTCALL\npoolGrow(STRING_POOL *pool) {\n  if (pool->freeBlocks) {\n    if (pool->start == NULL) {\n      pool->blocks = pool->freeBlocks;\n      pool->freeBlocks = pool->freeBlocks->next;\n      pool->blocks->next = NULL;\n      pool->start = pool->blocks->s;\n      pool->end = pool->start + pool->blocks->size;\n      pool->ptr = pool->start;\n      return XML_TRUE;\n    }\n    if (pool->end - pool->start < pool->freeBlocks->size) {\n      BLOCK *tem = pool->freeBlocks->next;\n      pool->freeBlocks->next = pool->blocks;\n      pool->blocks = pool->freeBlocks;\n      pool->freeBlocks = tem;\n      memcpy(pool->blocks->s, pool->start,\n             (pool->end - pool->start) * sizeof(XML_Char));\n      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);\n      pool->start = pool->blocks->s;\n      pool->end = pool->start + pool->blocks->size;\n      return XML_TRUE;\n    }\n  }\n  if (pool->blocks && pool->start == pool->blocks->s) {\n    BLOCK *temp;\n    int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);\n    size_t bytesToAllocate;\n\n    /* NOTE: Needs to be calculated prior to calling `realloc`\n             to avoid dangling pointers: */\n    const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;\n\n    if (blockSize < 0) {\n      /* This condition traps a situation where either more than\n       * INT_MAX/2 bytes have already been allocated.  This isn't\n       * readily testable, since it is unlikely that an average\n       * machine will have that much memory, so we exclude it from the\n       * coverage statistics.\n       */\n      return XML_FALSE; /* LCOV_EXCL_LINE */\n    }\n\n    bytesToAllocate = poolBytesToAllocateFor(blockSize);\n    if (bytesToAllocate == 0)\n      return XML_FALSE;\n\n    temp = REALLOC(pool->parser, pool->blocks, bytesToAllocate);\n    if (temp == NULL)\n      return XML_FALSE;\n    pool->blocks = temp;\n    pool->blocks->size = blockSize;\n    pool->ptr = pool->blocks->s + offsetInsideBlock;\n    pool->start = pool->blocks->s;\n    pool->end = pool->start + blockSize;\n  } else {\n    BLOCK *tem;\n    int blockSize = (int)(pool->end - pool->start);\n    size_t bytesToAllocate;\n\n    if (blockSize < 0) {\n      /* This condition traps a situation where either more than\n       * INT_MAX bytes have already been allocated (which is prevented\n       * by various pieces of program logic, not least this one, never\n       * mind the unlikelihood of actually having that much memory) or\n       * the pool control fields have been corrupted (which could\n       * conceivably happen in an extremely buggy user handler\n       * function).  Either way it isn't readily testable, so we\n       * exclude it from the coverage statistics.\n       */\n      return XML_FALSE; /* LCOV_EXCL_LINE */\n    }\n\n    if (blockSize < INIT_BLOCK_SIZE)\n      blockSize = INIT_BLOCK_SIZE;\n    else {\n      /* Detect overflow, avoiding _signed_ overflow undefined behavior */\n      if ((int)((unsigned)blockSize * 2U) < 0) {\n        return XML_FALSE;\n      }\n      blockSize *= 2;\n    }\n\n    bytesToAllocate = poolBytesToAllocateFor(blockSize);\n    if (bytesToAllocate == 0)\n      return XML_FALSE;\n\n    tem = MALLOC(pool->parser, bytesToAllocate);\n    if (! tem)\n      return XML_FALSE;\n    tem->size = blockSize;\n    tem->next = pool->blocks;\n    pool->blocks = tem;\n    if (pool->ptr != pool->start)\n      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));\n    pool->ptr = tem->s + (pool->ptr - pool->start);\n    pool->start = tem->s;\n    pool->end = tem->s + blockSize;\n  }\n  return XML_TRUE;\n}\n\nstatic int FASTCALL\nnextScaffoldPart(XML_Parser parser) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  CONTENT_SCAFFOLD *me;\n  int next;\n\n  if (! dtd->scaffIndex) {\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if (parser->m_groupSize > SIZE_MAX / sizeof(int)) {\n      return -1;\n    }\n#endif\n    dtd->scaffIndex = MALLOC(parser, parser->m_groupSize * sizeof(int));\n    if (! dtd->scaffIndex)\n      return -1;\n    dtd->scaffIndex[0] = 0;\n  }\n\n  // Will casting to int be safe further down?\n  if (dtd->scaffCount > INT_MAX) {\n    return -1;\n  }\n\n  if (dtd->scaffCount >= dtd->scaffSize) {\n    CONTENT_SCAFFOLD *temp;\n    if (dtd->scaffold) {\n      /* Detect and prevent integer overflow */\n      if (dtd->scaffSize > UINT_MAX / 2u) {\n        return -1;\n      }\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if (dtd->scaffSize > SIZE_MAX / 2u / sizeof(CONTENT_SCAFFOLD)) {\n        return -1;\n      }\n#endif\n\n      temp = REALLOC(parser, dtd->scaffold,\n                     dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));\n      if (temp == NULL)\n        return -1;\n      dtd->scaffSize *= 2;\n    } else {\n      temp = MALLOC(parser, INIT_SCAFFOLD_ELEMENTS * sizeof(CONTENT_SCAFFOLD));\n      if (temp == NULL)\n        return -1;\n      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;\n    }\n    dtd->scaffold = temp;\n  }\n  next = (int)dtd->scaffCount++;\n  me = &dtd->scaffold[next];\n  if (dtd->scaffLevel) {\n    CONTENT_SCAFFOLD *parent\n        = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];\n    if (parent->lastchild) {\n      dtd->scaffold[parent->lastchild].nextsib = next;\n    }\n    if (! parent->childcnt)\n      parent->firstchild = next;\n    parent->lastchild = next;\n    parent->childcnt++;\n  }\n  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;\n  return next;\n}\n\nstatic XML_Content *\nbuild_model(XML_Parser parser) {\n  /* Function build_model transforms the existing parser->m_dtd->scaffold\n   * array of CONTENT_SCAFFOLD tree nodes into a new array of\n   * XML_Content tree nodes followed by a gapless list of zero-terminated\n   * strings. */\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  XML_Content *ret;\n  XML_Char *str; /* the current string writing location */\n\n  /* Detect and prevent integer overflow.\n   * The preprocessor guard addresses the \"always false\" warning\n   * from -Wtype-limits on platforms where\n   * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n  if (dtd->scaffCount > SIZE_MAX / sizeof(XML_Content)) {\n    return NULL;\n  }\n  if (dtd->contentStringLen > SIZE_MAX / sizeof(XML_Char)) {\n    return NULL;\n  }\n#endif\n  if (dtd->scaffCount * sizeof(XML_Content)\n      > SIZE_MAX - dtd->contentStringLen * sizeof(XML_Char)) {\n    return NULL;\n  }\n\n  const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)\n                            + (dtd->contentStringLen * sizeof(XML_Char)));\n\n  // NOTE: We are avoiding MALLOC(..) here to so that\n  //       applications that are not using XML_FreeContentModel but plain\n  //       free(..) or .free_fcn() to free the content model's memory are safe.\n  ret = parser->m_mem.malloc_fcn(allocsize);\n  if (! ret)\n    return NULL;\n\n  /* What follows is an iterative implementation (of what was previously done\n   * recursively in a dedicated function called \"build_node\".  The old recursive\n   * build_node could be forced into stack exhaustion from input as small as a\n   * few megabyte, and so that was a security issue.  Hence, a function call\n   * stack is avoided now by resolving recursion.)\n   *\n   * The iterative approach works as follows:\n   *\n   * - We have two writing pointers, both walking up the result array; one does\n   *   the work, the other creates \"jobs\" for its colleague to do, and leads\n   *   the way:\n   *\n   *   - The faster one, pointer jobDest, always leads and writes \"what job\n   *     to do\" by the other, once they reach that place in the\n   *     array: leader \"jobDest\" stores the source node array index (relative\n   *     to array dtd->scaffold) in field \"numchildren\".\n   *\n   *   - The slower one, pointer dest, looks at the value stored in the\n   *     \"numchildren\" field (which actually holds a source node array index\n   *     at that time) and puts the real data from dtd->scaffold in.\n   *\n   * - Before the loop starts, jobDest writes source array index 0\n   *   (where the root node is located) so that dest will have something to do\n   *   when it starts operation.\n   *\n   * - Whenever nodes with children are encountered, jobDest appends\n   *   them as new jobs, in order.  As a result, tree node siblings are\n   *   adjacent in the resulting array, for example:\n   *\n   *     [0] root, has two children\n   *       [1] first child of 0, has three children\n   *         [3] first child of 1, does not have children\n   *         [4] second child of 1, does not have children\n   *         [5] third child of 1, does not have children\n   *       [2] second child of 0, does not have children\n   *\n   *   Or (the same data) presented in flat array view:\n   *\n   *     [0] root, has two children\n   *\n   *     [1] first child of 0, has three children\n   *     [2] second child of 0, does not have children\n   *\n   *     [3] first child of 1, does not have children\n   *     [4] second child of 1, does not have children\n   *     [5] third child of 1, does not have children\n   *\n   * - The algorithm repeats until all target array indices have been processed.\n   */\n  XML_Content *dest = ret; /* tree node writing location, moves upwards */\n  XML_Content *const destLimit = &ret[dtd->scaffCount];\n  XML_Content *jobDest = ret; /* next free writing location in target array */\n  str = (XML_Char *)&ret[dtd->scaffCount];\n\n  /* Add the starting job, the root node (index 0) of the source tree  */\n  (jobDest++)->numchildren = 0;\n\n  for (; dest < destLimit; dest++) {\n    /* Retrieve source tree array index from job storage */\n    const int src_node = (int)dest->numchildren;\n\n    /* Convert item */\n    dest->type = dtd->scaffold[src_node].type;\n    dest->quant = dtd->scaffold[src_node].quant;\n    if (dest->type == XML_CTYPE_NAME) {\n      const XML_Char *src;\n      dest->name = str;\n      src = dtd->scaffold[src_node].name;\n      for (;;) {\n        *str++ = *src;\n        if (! *src)\n          break;\n        src++;\n      }\n      dest->numchildren = 0;\n      dest->children = NULL;\n    } else {\n      unsigned int i;\n      int cn;\n      dest->name = NULL;\n      dest->numchildren = dtd->scaffold[src_node].childcnt;\n      dest->children = jobDest;\n\n      /* Append scaffold indices of children to array */\n      for (i = 0, cn = dtd->scaffold[src_node].firstchild;\n           i < dest->numchildren; i++, cn = dtd->scaffold[cn].nextsib)\n        (jobDest++)->numchildren = (unsigned int)cn;\n    }\n  }\n\n  return ret;\n}\n\nstatic ELEMENT_TYPE *\ngetElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,\n               const char *end) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);\n  ELEMENT_TYPE *ret;\n\n  if (! name)\n    return NULL;\n  ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,\n                               sizeof(ELEMENT_TYPE));\n  if (! ret)\n    return NULL;\n  if (ret->name != name)\n    poolDiscard(&dtd->pool);\n  else {\n    poolFinish(&dtd->pool);\n    if (! setElementTypePrefix(parser, ret))\n      return NULL;\n  }\n  return ret;\n}\n\nstatic XML_Char *\ncopyString(const XML_Char *s, XML_Parser parser) {\n  size_t charsRequired = 0;\n  XML_Char *result;\n\n  /* First determine how long the string is */\n  while (s[charsRequired] != 0) {\n    charsRequired++;\n  }\n  /* Include the terminator */\n  charsRequired++;\n\n  /* Now allocate space for the copy */\n  result = MALLOC(parser, charsRequired * sizeof(XML_Char));\n  if (result == NULL)\n    return NULL;\n  /* Copy the original into place */\n  memcpy(result, s, charsRequired * sizeof(XML_Char));\n  return result;\n}\n\n#if XML_GE == 1\n\nstatic float\naccountingGetCurrentAmplification(XML_Parser rootParser) {\n  //                                          1.........1.........12 => 22\n  const size_t lenOfShortestInclude = sizeof(\"<!ENTITY a SYSTEM 'b'>\") - 1;\n  const XmlBigCount countBytesOutput\n      = rootParser->m_accounting.countBytesDirect\n        + rootParser->m_accounting.countBytesIndirect;\n  const float amplificationFactor\n      = rootParser->m_accounting.countBytesDirect\n            ? ((float)countBytesOutput\n```", "role": "user"}, {"content": "diff --git a/expat/lib/xmlparse.c b/expat/lib/xmlparse.c\nindex 620d1e4b46..890a9389f1 100644\n--- a/expat/lib/xmlparse.c\n+++ b/expat/lib/xmlparse.c\n@@ -387,6 +387,7 @@ typedef struct {\n   int nDefaultAtts;\n   int allocDefaultAtts;\n   DEFAULT_ATTRIBUTE *defaultAtts;\n+  HASH_TABLE defaultAttsNames;\n } ELEMENT_TYPE;\n \n typedef struct {\n@@ -3769,6 +3770,8 @@ storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,\n                                          sizeof(ELEMENT_TYPE));\n     if (! elementType)\n       return XML_ERROR_NO_MEMORY;\n+    if (! elementType->defaultAttsNames.parser)\n+      hashTableInit(&(elementType->defaultAttsNames), parser);\n     if (parser->m_ns && ! setElementTypePrefix(parser, elementType))\n       return XML_ERROR_NO_MEMORY;\n   }\n@@ -7102,10 +7105,10 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n   if (value || isId) {\n     /* The handling of default attributes gets messed up if we have\n        a default which duplicates a non-default. */\n-    int i;\n-    for (i = 0; i < type->nDefaultAtts; i++)\n-      if (attId == type->defaultAtts[i].id)\n-        return 1;\n+    NAMED *const nameFound\n+        = (NAMED *)lookup(parser, &(type->defaultAttsNames), attId->name, 0);\n+    if (nameFound)\n+      return 1;\n     if (isId && ! type->idAtt && ! attId->xmlns)\n       type->idAtt = attId;\n   }\n@@ -7152,6 +7155,12 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n   att->isCdata = isCdata;\n   if (! isCdata)\n     attId->maybeTokenized = XML_TRUE;\n+\n+  NAMED *const nameAddedOrFound = (NAMED *)lookup(\n+      parser, &(type->defaultAttsNames), attId->name, sizeof(NAMED));\n+  if (! nameAddedOrFound)\n+    return 0;\n+\n   type->nDefaultAtts += 1;\n   return 1;\n }\n@@ -7477,6 +7486,7 @@ dtdReset(DTD *p, XML_Parser parser) {\n     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n     if (! e)\n       break;\n+    hashTableDestroy(&(e->defaultAttsNames));\n     if (e->allocDefaultAtts != 0)\n       FREE(parser, e->defaultAtts);\n   }\n@@ -7518,6 +7528,7 @@ dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser) {\n     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n     if (! e)\n       break;\n+    hashTableDestroy(&(e->defaultAttsNames));\n     if (e->allocDefaultAtts != 0)\n       FREE(parser, e->defaultAtts);\n   }\n@@ -7611,6 +7622,10 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n                                   sizeof(ELEMENT_TYPE));\n     if (! newE)\n       return 0;\n+\n+    if (! newE->defaultAttsNames.parser)\n+      hashTableInit(&(newE->defaultAttsNames), parser);\n+\n     if (oldE->nDefaultAtts) {\n       /* Detect and prevent integer overflow.\n        * The preprocessor guard addresses the \"always false\" warning\n@@ -7635,8 +7650,9 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n       newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                       oldE->prefix->name, 0);\n     for (i = 0; i < newE->nDefaultAtts; i++) {\n+      const XML_Char *const attributeName = oldE->defaultAtts[i].id->name;\n       newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(\n-          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);\n+          oldParser, &(newDtd->attributeIds), attributeName, 0);\n       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;\n       if (oldE->defaultAtts[i].value) {\n         newE->defaultAtts[i].value\n@@ -7645,6 +7661,12 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n           return 0;\n       } else\n         newE->defaultAtts[i].value = NULL;\n+\n+      NAMED *const nameAddedOrFound = (NAMED *)lookup(\n+          parser, &(newE->defaultAttsNames), attributeName, sizeof(NAMED));\n+      if (! nameAddedOrFound) {\n+        return 0;\n+      }\n     }\n   }\n \n@@ -8391,6 +8413,8 @@ getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,\n                                sizeof(ELEMENT_TYPE));\n   if (! ret)\n     return NULL;\n+  if (! ret->defaultAttsNames.parser)\n+    hashTableInit(&(ret->defaultAttsNames), getRootParserOf(parser, NULL));\n   if (ret->name != name)\n     poolDiscard(&dtd->pool);\n   else {", "role": "assistant"}]}
{"messages": [{"content": "You are a security engineer fixing a CVE. You are given the vulnerability description (symptom only) and the vulnerable source window. Author the MINIMAL fix as a unified diff. Follow these rules exactly:\n1. Target ONLY the file named in the `# Vulnerable source (...)` header \u2014 do not invent or substitute file paths.\n2. Modify ONLY code visible in the shown source window.\n3. Change as few lines as possible; do not rewrite surrounding logic.\n4. Output only the unified diff with no other text.\n5. Prefer the minimal structural change: if an existing condition is missing a check, add it inline to that condition rather than inserting a new code block. If existing code is redundant or overcomplicated, replace it \u2014 do not add more code around it.\n6. Edit the most specific method or class that directly handles the vulnerable operation \u2014 not a base class, interface, or Protocol definition.", "role": "system"}, {"content": "# CVE\nCVE-2026-45186: Expat through 2.8.0 has quadratic time complexity when processing XML documents with a large number of duplicate default attribute definitions.\n\n# Vulnerable source (lib/xmlparse.c)\n```c\ntypedef struct block {\n  struct block *next;\n  int size;\n  XML_Char s[];\n} BLOCK;\n\ntypedef struct {\n  BLOCK *blocks;\n  BLOCK *freeBlocks;\n  const XML_Char *end;\n  XML_Char *ptr;\n  XML_Char *start;\n  XML_Parser parser;\n} STRING_POOL;\n\n/* The XML_Char before the name is used to determine whether\n   an attribute has been specified. */\ntypedef struct attribute_id {\n  XML_Char *name;\n  PREFIX *prefix;\n  XML_Bool maybeTokenized;\n  XML_Bool xmlns;\n} ATTRIBUTE_ID;\n\ntypedef struct {\n  const ATTRIBUTE_ID *id;\n  XML_Bool isCdata;\n  const XML_Char *value;\n} DEFAULT_ATTRIBUTE;\n\ntypedef struct {\n  unsigned long version;\n  unsigned long hash;\n  const XML_Char *uriName;\n} NS_ATT;\n\ntypedef struct {\n  const XML_Char *name;\n  PREFIX *prefix;\n  const ATTRIBUTE_ID *idAtt;\n  int nDefaultAtts;\n  int allocDefaultAtts;\n  DEFAULT_ATTRIBUTE *defaultAtts;\n} ELEMENT_TYPE;\n\ntypedef struct {\n  HASH_TABLE generalEntities;\n  HASH_TABLE elementTypes;\n  HASH_TABLE attributeIds;\n  HASH_TABLE prefixes;\n  STRING_POOL pool;\n  STRING_POOL entityValuePool;\n  /* false once a parameter entity reference has been skipped */\n  XML_Bool keepProcessing;\n  /* true once an internal or external PE reference has been encountered;\n     this includes the reference to an external subset */\n  XML_Bool hasParamEntityRefs;\n  XML_Bool standalone;\n#ifdef XML_DTD\n  /* indicates if external PE has been read */\n  XML_Bool paramEntityRead;\n  HASH_TABLE paramEntities;\n#endif /* XML_DTD */\n  PREFIX defaultPrefix;\n  /* === scaffolding for building content model === */\n  XML_Bool in_eldecl;\n  CONTENT_SCAFFOLD *scaffold;\n  unsigned contentStringLen;\n  unsigned scaffSize;\n  unsigned scaffCount;\n  int scaffLevel;\n  int *scaffIndex;\n} DTD;\n\nenum EntityType {\n  ENTITY_INTERNAL,\n  ENTITY_ATTRIBUTE,\n  ENTITY_VALUE,\n};\n\ntypedef struct open_internal_entity {\n  const char *internalEventPtr;\n  const char *internalEventEndPtr;\n  struct open_internal_entity *next;\n  ENTITY *entity;\n  int startTagLevel;\n  XML_Bool betweenDecl; /* WFC: PE Between Declarations */\n  enum EntityType type;\n} OPEN_INTERNAL_ENTITY;\n\nenum XML_Account {\n  XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */\n  XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity\n                                   expansion */\n  XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */\n};\n\n#if XML_GE == 1\ntypedef unsigned long long XmlBigCount;\ntypedef struct accounting {\n  XmlBigCount countBytesDirect;\n  XmlBigCount countBytesIndirect;\n  unsigned long debugLevel;\n  float maximumAmplificationFactor; // >=1.0\n  unsigned long long activationThresholdBytes;\n} ACCOUNTING;\n\ntypedef struct MALLOC_TRACKER {\n  XmlBigCount bytesAllocated;\n  XmlBigCount peakBytesAllocated; // updated live only for debug level >=2\n  unsigned long debugLevel;\n  float maximumAmplificationFactor; // >=1.0\n  XmlBigCount activationThresholdBytes;\n} MALLOC_TRACKER;\n\ntypedef struct entity_stats {\n  unsigned int countEverOpened;\n  unsigned int currentDepth;\n  unsigned int maximumDepthSeen;\n  unsigned long debugLevel;\n} ENTITY_STATS;\n#endif /* XML_GE == 1 */\n\ntypedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,\n                                         const char *end, const char **endPtr);\n\nstatic Processor prologProcessor;\nstatic Processor prologInitProcessor;\nstatic Processor contentProcessor;\nstatic Processor cdataSectionProcessor;\n#ifdef XML_DTD\nstatic Processor ignoreSectionProcessor;\nstatic Processor externalParEntProcessor;\nstatic Processor externalParEntInitProcessor;\nstatic Processor entityValueProcessor;\nstatic Processor entityValueInitProcessor;\n#endif /* XML_DTD */\nstatic Processor epilogProcessor;\nstatic Processor errorProcessor;\nstatic Processor externalEntityInitProcessor;\nstatic Processor externalEntityInitProcessor2;\nstatic Processor externalEntityInitProcessor3;\nstatic Processor externalEntityContentProcessor;\nstatic Processor internalEntityProcessor;\n\nstatic enum XML_Error handleUnknownEncoding(XML_Parser parser,\n                                            const XML_Char *encodingName);\nstatic enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,\n                                     const char *s, const char *next);\nstatic enum XML_Error initializeEncoding(XML_Parser parser);\nstatic enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,\n                               const char *s, const char *end, int tok,\n                               const char *next, const char **nextPtr,\n                               XML_Bool haveMore, XML_Bool allowClosingDoctype,\n                               enum XML_Account account);\nstatic enum XML_Error processEntity(XML_Parser parser, ENTITY *entity,\n                                    XML_Bool betweenDecl, enum EntityType type);\nstatic enum XML_Error doContent(XML_Parser parser, int startTagLevel,\n                                const ENCODING *enc, const char *start,\n                                const char *end, const char **endPtr,\n                                XML_Bool haveMore, enum XML_Account account);\nstatic enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *enc,\n                                     const char **startPtr, const char *end,\n                                     const char **nextPtr, XML_Bool haveMore,\n                                     enum XML_Account account);\n#ifdef XML_DTD\nstatic enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *enc,\n                                      const char **startPtr, const char *end,\n                                      const char **nextPtr, XML_Bool haveMore);\n#endif /* XML_DTD */\n\nstatic void freeBindings(XML_Parser parser, BINDING *bindings);\nstatic enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,\n                                const char *attStr, TAG_NAME *tagNamePtr,\n                                BINDING **bindingsPtr,\n                                enum XML_Account account);\nstatic enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,\n                                 const ATTRIBUTE_ID *attId, const XML_Char *uri,\n                                 BINDING **bindingsPtr);\nstatic int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId,\n                           XML_Bool isCdata, XML_Bool isId,\n                           const XML_Char *value, XML_Parser parser);\nstatic enum XML_Error storeAttributeValue(XML_Parser parser,\n                                          const ENCODING *enc, XML_Bool isCdata,\n                                          const char *ptr, const char *end,\n                                          STRING_POOL *pool,\n                                          enum XML_Account account);\nstatic enum XML_Error\nappendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                     const char *ptr, const char *end, STRING_POOL *pool,\n                     enum XML_Account account, const char **nextPtr);\nstatic ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,\n                                    const char *start, const char *end);\nstatic int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType);\n#if XML_GE == 1\nstatic enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,\n                                       const char *start, const char *end,\n                                       enum XML_Account account,\n                                       const char **nextPtr);\nstatic enum XML_Error callStoreEntityValue(XML_Parser parser,\n                                           const ENCODING *enc,\n                                           const char *start, const char *end,\n                                           enum XML_Account account);\n#else\nstatic enum XML_Error storeSelfEntityValue(XML_Parser parser, ENTITY *entity);\n#endif\nstatic int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\n                                       const char *start, const char *end);\nstatic int reportComment(XML_Parser parser, const ENCODING *enc,\n                         const char *start, const char *end);\nstatic void reportDefault(XML_Parser parser, const ENCODING *enc,\n                          const char *start, const char *end);\n\nstatic const XML_Char *getContext(XML_Parser parser);\nstatic XML_Bool setContext(XML_Parser parser, const XML_Char *context);\n\nstatic void FASTCALL normalizePublicId(XML_Char *s);\n\nstatic DTD *dtdCreate(XML_Parser parser);\n/* do not call if m_parentParser != NULL */\nstatic void dtdReset(DTD *p, XML_Parser parser);\nstatic void dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser);\nstatic int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n                   XML_Parser parser);\nstatic int copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,\n                           STRING_POOL *newPool, const HASH_TABLE *oldTable);\nstatic NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,\n                     size_t createSize);\nstatic void FASTCALL hashTableInit(HASH_TABLE *table, XML_Parser parser);\nstatic void FASTCALL hashTableClear(HASH_TABLE *table);\nstatic void FASTCALL hashTableDestroy(HASH_TABLE *table);\nstatic void FASTCALL hashTableIterInit(HASH_TABLE_ITER *iter,\n                                       const HASH_TABLE *table);\nstatic NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *iter);\n\nstatic void FASTCALL poolInit(STRING_POOL *pool, XML_Parser parser);\nstatic void FASTCALL poolClear(STRING_POOL *pool);\nstatic void FASTCALL poolDestroy(STRING_POOL *pool);\nstatic XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,\n                            const char *ptr, const char *end);\nstatic XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,\n                                 const char *ptr, const char *end);\nstatic XML_Bool FASTCALL poolGrow(STRING_POOL *pool);\nstatic const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,\n                                               const XML_Char *s);\nstatic const XML_Char *FASTCALL poolCopyStringNoFinish(STRING_POOL *pool,\n                                                       const XML_Char *s);\nstatic const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,\n                                       int n);\nstatic const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,\n                                                 const XML_Char *s);\n\nstatic int FASTCALL nextScaffoldPart(XML_Parser parser);\nstatic XML_Content *build_model(XML_Parser parser);\nstatic ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,\n                                    const char *ptr, const char *end);\n\nstatic XML_Char *copyString(const XML_Char *s, XML_Parser parser);\n\nstatic struct sipkey generate_hash_secret_salt(void);\nstatic XML_Bool startParsing(XML_Parser parser);\n\nstatic XML_Parser parserCreate(const XML_Char *encodingName,\n                               const XML_Memory_Handling_Suite *memsuite,\n                               const XML_Char *nameSep, DTD *dtd,\n                               XML_Parser parentParser);\n\nstatic void parserInit(XML_Parser parser, const XML_Char *encodingName);\n\n#if XML_GE == 1\nstatic float accountingGetCurrentAmplification(XML_Parser rootParser);\nstatic void accountingReportStats(XML_Parser originParser, const char *epilog);\nstatic void accountingOnAbort(XML_Parser originParser);\nstatic void accountingReportDiff(XML_Parser rootParser,\n                                 unsigned int levelsAwayFromRootParser,\n                                 const char *before, const char *after,\n                                 ptrdiff_t bytesMore, int source_line,\n                                 enum XML_Account account);\nstatic XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,\n                                        const char *before, const char *after,\n                                        int source_line,\n                                        enum XML_Account account);\n\nstatic void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,\n                                      const char *action, int sourceLine);\nstatic void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,\n                                 int sourceLine);\nstatic void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,\n                                  int sourceLine);\n#endif /* XML_GE == 1 */\n\nstatic XML_Parser getRootParserOf(XML_Parser parser,\n                                  unsigned int *outLevelDiff);\n\nstatic unsigned long getDebugLevel(const char *variableName,\n                                   unsigned long defaultDebugLevel);\n\n#define poolStart(pool) ((pool)->start)\n#define poolLength(pool) ((pool)->ptr - (pool)->start)\n#define poolChop(pool) ((void)--(pool->ptr))\n#define poolLastChar(pool) (((pool)->ptr)[-1])\n#define poolDiscard(pool) ((pool)->ptr = (pool)->start)\n#define poolFinish(pool) ((pool)->start = (pool)->ptr)\n#define poolAppendChar(pool, c)                                                \\\n  (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \\\n       ? 0                                                                     \\\n       : ((*((pool)->ptr)++ = c), 1))\n\n#if ! defined(XML_TESTING)\nconst\n#endif\n    XML_Bool g_reparseDeferralEnabledDefault\n    = XML_TRUE; // write ONLY in runtests.c\n#if defined(XML_TESTING)\nunsigned int g_bytesScanned = 0; // used for testing only\n#endif\n\nstruct XML_ParserStruct {\n  /* The first member must be m_userData so that the XML_GetUserData\n     macro works. */\n  void *m_userData;\n  void *m_handlerArg;\n\n  // How the four parse buffer pointers below relate in time and space:\n  //\n  //   m_buffer <= m_bufferPtr <= m_bufferEnd  <= m_bufferLim\n  //   |           |              |               |\n  //   <--parsed-->|              |               |\n  //               <---parsing--->|               |\n  //                              <--unoccupied-->|\n  //   <---------total-malloced/realloced-------->|\n\n  char *m_buffer; // malloc/realloc base pointer of parse buffer\n  const XML_Memory_Handling_Suite m_mem;\n  const char *m_bufferPtr; // first character to be parsed\n  char *m_bufferEnd;       // past last character to be parsed\n  const char *m_bufferLim; // allocated end of m_buffer\n\n  XML_Index m_parseEndByteIndex;\n  const char *m_parseEndPtr;\n  size_t m_partialTokenBytesBefore; /* used in heuristic to avoid O(n^2) */\n  XML_Bool m_reparseDeferralEnabled;\n  int m_lastBufferRequestSize;\n  XML_Char *m_dataBuf;\n  XML_Char *m_dataBufEnd;\n  XML_StartElementHandler m_startElementHandler;\n  XML_EndElementHandler m_endElementHandler;\n  XML_CharacterDataHandler m_characterDataHandler;\n  XML_ProcessingInstructionHandler m_processingInstructionHandler;\n  XML_CommentHandler m_commentHandler;\n  XML_StartCdataSectionHandler m_startCdataSectionHandler;\n  XML_EndCdataSectionHandler m_endCdataSectionHandler;\n  XML_DefaultHandler m_defaultHandler;\n  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;\n  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;\n  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;\n  XML_NotationDeclHandler m_notationDeclHandler;\n  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;\n  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;\n  XML_NotStandaloneHandler m_notStandaloneHandler;\n  XML_ExternalEntityRefHandler m_externalEntityRefHandler;\n  XML_Parser m_externalEntityRefHandlerArg;\n  XML_SkippedEntityHandler m_skippedEntityHandler;\n  XML_UnknownEncodingHandler m_unknownEncodingHandler;\n  XML_ElementDeclHandler m_elementDeclHandler;\n  XML_AttlistDeclHandler m_attlistDeclHandler;\n  XML_EntityDeclHandler m_entityDeclHandler;\n  XML_XmlDeclHandler m_xmlDeclHandler;\n  const ENCODING *m_encoding;\n  INIT_ENCODING m_initEncoding;\n  const ENCODING *m_internalEncoding;\n  const XML_Char *m_protocolEncodingName;\n  XML_Bool m_ns;\n  XML_Bool m_ns_triplets;\n  void *m_unknownEncodingMem;\n  void *m_unknownEncodingData;\n  void *m_unknownEncodingHandlerData;\n  void(XMLCALL *m_unknownEncodingRelease)(void *);\n  PROLOG_STATE m_prologState;\n  Processor *m_processor;\n  enum XML_Error m_errorCode;\n  const char *m_eventPtr;\n  const char *m_eventEndPtr;\n  const char *m_positionPtr;\n  OPEN_INTERNAL_ENTITY *m_openInternalEntities;\n  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;\n  OPEN_INTERNAL_ENTITY *m_openAttributeEntities;\n  OPEN_INTERNAL_ENTITY *m_freeAttributeEntities;\n  OPEN_INTERNAL_ENTITY *m_openValueEntities;\n  OPEN_INTERNAL_ENTITY *m_freeValueEntities;\n  XML_Bool m_defaultExpandInternalEntities;\n  int m_tagLevel;\n  ENTITY *m_declEntity;\n  const XML_Char *m_doctypeName;\n  const XML_Char *m_doctypeSysid;\n  const XML_Char *m_doctypePubid;\n  const XML_Char *m_declAttributeType;\n  const XML_Char *m_declNotationName;\n  const XML_Char *m_declNotationPublicId;\n  ELEMENT_TYPE *m_declElementType;\n  ATTRIBUTE_ID *m_declAttributeId;\n  XML_Bool m_declAttributeIsCdata;\n  XML_Bool m_declAttributeIsId;\n  DTD *m_dtd;\n  const XML_Char *m_curBase;\n  TAG *m_tagStack;\n  TAG *m_freeTagList;\n  BINDING *m_inheritedBindings;\n  BINDING *m_freeBindingList;\n  int m_attsSize;\n  int m_nSpecifiedAtts;\n  int m_idAttIndex;\n  ATTRIBUTE *m_atts;\n  NS_ATT *m_nsAtts;\n  unsigned long m_nsAttsVersion;\n  unsigned char m_nsAttsPower;\n#ifdef XML_ATTR_INFO\n  XML_AttrInfo *m_attInfo;\n#endif\n  POSITION m_position;\n  STRING_POOL m_tempPool;\n  STRING_POOL m_temp2Pool;\n  char *m_groupConnector;\n  unsigned int m_groupSize;\n  XML_Char m_namespaceSeparator;\n  XML_Parser m_parentParser;\n  XML_ParsingStatus m_parsingStatus;\n#ifdef XML_DTD\n  XML_Bool m_isParamEntity;\n  XML_Bool m_useForeignDTD;\n  enum XML_ParamEntityParsing m_paramEntityParsing;\n#endif\n  struct sipkey m_hash_secret_salt_128;\n  XML_Bool m_hash_secret_salt_set;\n#if XML_GE == 1\n  ACCOUNTING m_accounting;\n  MALLOC_TRACKER m_alloc_tracker;\n  ENTITY_STATS m_entity_stats;\n#endif\n  XML_Bool m_reenter;\n};\n\n#if XML_GE == 1\n#  define MALLOC(parser, s) (expat_malloc((parser), (s), __LINE__))\n#  define REALLOC(parser, p, s) (expat_realloc((parser), (p), (s), __LINE__))\n#  define FREE(parser, p) (expat_free((parser), (p), __LINE__))\n#else\n#  define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))\n#  define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))\n#  define FREE(parser, p) (parser->m_mem.free_fcn((p)))\n#endif\n\n#if XML_GE == 1\nstatic void\nexpat_heap_stat(XML_Parser rootParser, char operator, XmlBigCount absDiff,\n                XmlBigCount newTotal, XmlBigCount peakTotal, int sourceLine) {\n  // NOTE: This can be +infinity or -nan\n  const float amplification\n      = (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;\n  fprintf(\n      stderr,\n      \"expat: Allocations(%p): Direct \" EXPAT_FMT_ULL(\"10\") \", allocated %c\" EXPAT_FMT_ULL(\n          \"10\") \" to \" EXPAT_FMT_ULL(\"10\") \" (\" EXPAT_FMT_ULL(\"10\") \" peak), amplification %8.2f (xmlparse.c:%d)\\n\",\n      (void *)rootParser, rootParser->m_accounting.countBytesDirect, operator,\n      absDiff, newTotal, peakTotal, (double)amplification, sourceLine);\n}\n\nstatic bool\nexpat_heap_increase_tolerable(XML_Parser rootParser, XmlBigCount increase,\n                              int sourceLine) {\n  assert(rootParser != NULL);\n  assert(increase > 0);\n\n  XmlBigCount newTotal = 0;\n  bool tolerable = true;\n\n  // Detect integer overflow\n  if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated < increase) {\n    tolerable = false;\n  } else {\n    newTotal = rootParser->m_alloc_tracker.bytesAllocated + increase;\n\n    if (newTotal >= rootParser->m_alloc_tracker.activationThresholdBytes) {\n      assert(newTotal > 0);\n      // NOTE: This can be +infinity when dividing by zero but not -nan\n      const float amplification\n          = (float)newTotal / (float)rootParser->m_accounting.countBytesDirect;\n      if (amplification\n          > rootParser->m_alloc_tracker.maximumAmplificationFactor) {\n        tolerable = false;\n      }\n    }\n  }\n\n  if (! tolerable && (rootParser->m_alloc_tracker.debugLevel >= 1)) {\n    expat_heap_stat(rootParser, '+', increase, newTotal, newTotal, sourceLine);\n  }\n\n  return tolerable;\n}\n\n#  if defined(XML_TESTING)\nvoid *\n#  else\nstatic void *\n#  endif\nexpat_malloc(XML_Parser parser, size_t size, int sourceLine) {\n  // Detect integer overflow\n  if (SIZE_MAX - size < sizeof(size_t) + EXPAT_MALLOC_PADDING) {\n    return NULL;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  const size_t bytesToAllocate = sizeof(size_t) + EXPAT_MALLOC_PADDING + size;\n\n  if ((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated\n      < bytesToAllocate) {\n    return NULL; // i.e. signal integer overflow as out-of-memory\n  }\n\n  if (! expat_heap_increase_tolerable(rootParser, bytesToAllocate,\n                                      sourceLine)) {\n    return NULL; // i.e. signal violation as out-of-memory\n  }\n\n  // Actually allocate\n  void *const mallocedPtr = parser->m_mem.malloc_fcn(bytesToAllocate);\n\n  if (mallocedPtr == NULL) {\n    return NULL;\n  }\n\n  // Update in-block recorded size\n  *(size_t *)mallocedPtr = size;\n\n  // Update accounting\n  rootParser->m_alloc_tracker.bytesAllocated += bytesToAllocate;\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n    expat_heap_stat(rootParser, '+', bytesToAllocate,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING;\n}\n\n#  if defined(XML_TESTING)\nvoid\n#  else\nstatic void\n#  endif\nexpat_free(XML_Parser parser, void *ptr, int sourceLine) {\n  assert(parser != NULL);\n\n  if (ptr == NULL) {\n    return;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  // Extract size (to the eyes of malloc_fcn/realloc_fcn) and\n  // the original pointer returned by malloc/realloc\n  void *const mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);\n  const size_t bytesAllocated\n      = sizeof(size_t) + EXPAT_MALLOC_PADDING + *(size_t *)mallocedPtr;\n\n  // Update accounting\n  assert(rootParser->m_alloc_tracker.bytesAllocated >= bytesAllocated);\n  rootParser->m_alloc_tracker.bytesAllocated -= bytesAllocated;\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    expat_heap_stat(rootParser, '-', bytesAllocated,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  // NOTE: This may be freeing rootParser, so freeing has to come last\n  parser->m_mem.free_fcn(mallocedPtr);\n}\n\n#  if defined(XML_TESTING)\nvoid *\n#  else\nstatic void *\n#  endif\nexpat_realloc(XML_Parser parser, void *ptr, size_t size, int sourceLine) {\n  assert(parser != NULL);\n\n  if (ptr == NULL) {\n    return expat_malloc(parser, size, sourceLine);\n  }\n\n  if (size == 0) {\n    expat_free(parser, ptr, sourceLine);\n    return NULL;\n  }\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n\n  // Extract original size (to the eyes of the caller) and the original\n  // pointer returned by malloc/realloc\n  void *mallocedPtr = (char *)ptr - EXPAT_MALLOC_PADDING - sizeof(size_t);\n  const size_t prevSize = *(size_t *)mallocedPtr;\n\n  // Classify upcoming change\n  const bool isIncrease = (size > prevSize);\n  const size_t absDiff\n      = (size > prevSize) ? (size - prevSize) : (prevSize - size);\n\n  // Ask for permission from accounting\n  if (isIncrease) {\n    if (! expat_heap_increase_tolerable(rootParser, absDiff, sourceLine)) {\n      return NULL; // i.e. signal violation as out-of-memory\n    }\n  }\n\n  // NOTE: Integer overflow detection has already been done for us\n  //       by expat_heap_increase_tolerable(..) above\n  assert(SIZE_MAX - sizeof(size_t) - EXPAT_MALLOC_PADDING >= size);\n\n  // Actually allocate\n  mallocedPtr = parser->m_mem.realloc_fcn(\n      mallocedPtr, sizeof(size_t) + EXPAT_MALLOC_PADDING + size);\n\n  if (mallocedPtr == NULL) {\n    return NULL;\n  }\n\n  // Update accounting\n  if (isIncrease) {\n    assert((XmlBigCount)-1 - rootParser->m_alloc_tracker.bytesAllocated\n           >= absDiff);\n    rootParser->m_alloc_tracker.bytesAllocated += absDiff;\n  } else { // i.e. decrease\n    assert(rootParser->m_alloc_tracker.bytesAllocated >= absDiff);\n    rootParser->m_alloc_tracker.bytesAllocated -= absDiff;\n  }\n\n  // Report as needed\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n    expat_heap_stat(rootParser, isIncrease ? '+' : '-', absDiff,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, sourceLine);\n  }\n\n  // Update in-block recorded size\n  *(size_t *)mallocedPtr = size;\n\n  return (char *)mallocedPtr + sizeof(size_t) + EXPAT_MALLOC_PADDING;\n}\n#endif // XML_GE == 1\n\nXML_Parser XMLCALL\nXML_ParserCreate(const XML_Char *encodingName) {\n  return XML_ParserCreate_MM(encodingName, NULL, NULL);\n}\n\nXML_Parser XMLCALL\nXML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {\n  XML_Char tmp[2] = {nsSep, 0};\n  return XML_ParserCreate_MM(encodingName, NULL, tmp);\n}\n\n// \"xml=http://www.w3.org/XML/1998/namespace\"\nstatic const XML_Char implicitContext[]\n    = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,\n       ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,\n       ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,\n       ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,\n       ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,\n       ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,\n       ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,\n       ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,\n       '\\0'};\n\n#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)\n\nstatic unsigned long\ngather_time_entropy(void) {\n#  ifdef _WIN32\n  FILETIME ft;\n  GetSystemTimeAsFileTime(&ft); /* never fails */\n  return ft.dwHighDateTime ^ ft.dwLowDateTime;\n#  else\n  struct timeval tv;\n  int gettimeofday_res;\n\n  gettimeofday_res = gettimeofday(&tv, NULL);\n\n#    if defined(NDEBUG)\n  (void)gettimeofday_res;\n#    else\n  assert(gettimeofday_res == 0);\n#    endif /* defined(NDEBUG) */\n\n  /* Microseconds time is <20 bits entropy */\n  return tv.tv_usec;\n#  endif\n}\n\n#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */\n\nstatic struct sipkey\nENTROPY_DEBUG(const char *label, struct sipkey entropy_128) {\n  if (getDebugLevel(\"EXPAT_ENTROPY_DEBUG\", 0) >= 1u) {\n    fprintf(stderr,\n            \"expat: Entropy: %s --> [0x\" EXPAT_FMT_LLX(\n                \"016\") \", 0x\" EXPAT_FMT_LLX(\"016\") \"] (16 bytes)\\n\",\n            label, (unsigned long long)entropy_128.k[0],\n            (unsigned long long)entropy_128.k[1]);\n  }\n  return entropy_128;\n}\n\nstatic struct sipkey\ngenerate_hash_secret_salt(void) {\n  struct sipkey entropy;\n\n  /* \"Failproof\" high quality providers: */\n#if defined(HAVE_ARC4RANDOM_BUF)\n  writeRandomBytes_arc4random_buf(&entropy, sizeof(entropy));\n  return ENTROPY_DEBUG(\"arc4random_buf\", entropy);\n#elif defined(HAVE_ARC4RANDOM)\n  writeRandomBytes_arc4random(&entropy, sizeof(entropy));\n  return ENTROPY_DEBUG(\"arc4random\", entropy);\n#else\n  /* Try high quality providers first .. */\n#  ifdef _WIN32\n  if (writeRandomBytes_rand_s(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"rand_s\", entropy);\n  }\n#  elif defined(HAVE_GETENTROPY)\n  if (writeRandomBytes_getentropy(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"getentropy\", entropy);\n  }\n  errno = 0;\n#  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)\n  if (writeRandomBytes_getrandom_nonblock(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"getrandom\", entropy);\n  }\n#  endif\n#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)\n  if (writeRandomBytes_dev_urandom(&entropy, sizeof(entropy))) {\n    return ENTROPY_DEBUG(\"/dev/urandom\", entropy);\n  }\n#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */\n  /* .. and self-made low quality for backup: */\n\n  entropy.k[0] = 0;\n  entropy.k[1] = gather_time_entropy();\n#  if ! defined(__wasi__)\n  /* Process ID is 0 bits entropy if attacker has local access */\n  entropy.k[1] ^= getpid();\n#  endif\n\n  /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */\n  if (sizeof(unsigned long) == 4) {\n    entropy.k[1] *= 2147483647;\n    return ENTROPY_DEBUG(\"fallback(4)\", entropy);\n  } else {\n    entropy.k[1] *= 2305843009213693951ULL;\n    return ENTROPY_DEBUG(\"fallback(8)\", entropy);\n  }\n#endif\n}\n\nstatic enum XML_Error\ncallProcessor(XML_Parser parser, const char *start, const char *end,\n              const char **endPtr) {\n  const size_t have_now = EXPAT_SAFE_PTR_DIFF(end, start);\n\n  if (parser->m_reparseDeferralEnabled\n      && ! parser->m_parsingStatus.finalBuffer) {\n    // Heuristic: don't try to parse a partial token again until the amount of\n    // available data has increased significantly.\n    const size_t had_before = parser->m_partialTokenBytesBefore;\n    // ...but *do* try anyway if we're close to causing a reallocation.\n    size_t available_buffer\n        = EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);\n#if XML_CONTEXT_BYTES > 0\n    available_buffer -= EXPAT_MIN(available_buffer, XML_CONTEXT_BYTES);\n#endif\n    available_buffer\n        += EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd);\n    // m_lastBufferRequestSize is never assigned a value < 0, so the cast is ok\n    const bool enough\n        = (have_now >= 2 * had_before)\n          || ((size_t)parser->m_lastBufferRequestSize > available_buffer);\n\n    if (! enough) {\n      *endPtr = start; // callers may expect this to be set\n      return XML_ERROR_NONE;\n    }\n  }\n#if defined(XML_TESTING)\n  g_bytesScanned += (unsigned)have_now;\n#endif\n  // Run in a loop to eliminate dangerous recursion depths\n  enum XML_Error ret;\n  *endPtr = start;\n  while (1) {\n    // Use endPtr as the new start in each iteration, since it will\n    // be set to the next start point by m_processor.\n    ret = parser->m_processor(parser, *endPtr, end, endPtr);\n\n    // Make parsing status (and in particular XML_SUSPENDED) take\n    // precedence over re-enter flag when they disagree\n    if (parser->m_parsingStatus.parsing != XML_PARSING) {\n      parser->m_reenter = XML_FALSE;\n    }\n\n    if (! parser->m_reenter) {\n      break;\n    }\n\n    parser->m_reenter = XML_FALSE;\n    if (ret != XML_ERROR_NONE)\n      return ret;\n  }\n\n  if (ret == XML_ERROR_NONE) {\n    // if we consumed nothing, remember what we had on this parse attempt.\n    if (*endPtr == start) {\n      parser->m_partialTokenBytesBefore = have_now;\n    } else {\n      parser->m_partialTokenBytesBefore = 0;\n    }\n  }\n  return ret;\n}\n\nstatic XML_Bool /* only valid for root parser */\nstartParsing(XML_Parser parser) {\n  /* hash functions must be initialized before setContext() is called */\n  if (parser->m_hash_secret_salt_set != XML_TRUE) {\n    parser->m_hash_secret_salt_128 = generate_hash_secret_salt();\n    parser->m_hash_secret_salt_set = XML_TRUE;\n  }\n  if (parser->m_ns) {\n    /* implicit context only set for root parser, since child\n       parsers (i.e. external entity parsers) will inherit it\n    */\n    return setContext(parser, implicitContext);\n  }\n  return XML_TRUE;\n}\n\nXML_Parser XMLCALL\nXML_ParserCreate_MM(const XML_Char *encodingName,\n                    const XML_Memory_Handling_Suite *memsuite,\n                    const XML_Char *nameSep) {\n  return parserCreate(encodingName, memsuite, nameSep, NULL, NULL);\n}\n\nstatic XML_Parser\nparserCreate(const XML_Char *encodingName,\n             const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,\n             DTD *dtd, XML_Parser parentParser) {\n  XML_Parser parser = NULL;\n\n#if XML_GE == 1\n  const size_t increase\n      = sizeof(size_t) + EXPAT_MALLOC_PADDING + sizeof(struct XML_ParserStruct);\n\n  if (parentParser != NULL) {\n    const XML_Parser rootParser = getRootParserOf(parentParser, NULL);\n    if (! expat_heap_increase_tolerable(rootParser, increase, __LINE__)) {\n      return NULL;\n    }\n  }\n#else\n  UNUSED_P(parentParser);\n#endif\n\n  if (memsuite) {\n    XML_Memory_Handling_Suite *mtemp;\n#if XML_GE == 1\n    void *const sizeAndParser\n        = memsuite->malloc_fcn(sizeof(size_t) + EXPAT_MALLOC_PADDING\n                               + sizeof(struct XML_ParserStruct));\n    if (sizeAndParser != NULL) {\n      *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct);\n      parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t)\n                            + EXPAT_MALLOC_PADDING);\n#else\n    parser = memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));\n    if (parser != NULL) {\n#endif\n      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\n      mtemp->malloc_fcn = memsuite->malloc_fcn;\n      mtemp->realloc_fcn = memsuite->realloc_fcn;\n      mtemp->free_fcn = memsuite->free_fcn;\n    }\n  } else {\n    XML_Memory_Handling_Suite *mtemp;\n#if XML_GE == 1\n    void *const sizeAndParser = malloc(sizeof(size_t) + EXPAT_MALLOC_PADDING\n                                       + sizeof(struct XML_ParserStruct));\n    if (sizeAndParser != NULL) {\n      *(size_t *)sizeAndParser = sizeof(struct XML_ParserStruct);\n      parser = (XML_Parser)((char *)sizeAndParser + sizeof(size_t)\n                            + EXPAT_MALLOC_PADDING);\n#else\n    parser = malloc(sizeof(struct XML_ParserStruct));\n    if (parser != NULL) {\n#endif\n      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);\n      mtemp->malloc_fcn = malloc;\n      mtemp->realloc_fcn = realloc;\n      mtemp->free_fcn = free;\n    }\n  } // cppcheck-suppress[memleak symbolName=sizeAndParser] // Cppcheck >=2.18.0\n\n  if (! parser)\n    return parser;\n\n#if XML_GE == 1\n  // Initialize .m_alloc_tracker\n  memset(&parser->m_alloc_tracker, 0, sizeof(MALLOC_TRACKER));\n  if (parentParser == NULL) {\n    parser->m_alloc_tracker.debugLevel\n        = getDebugLevel(\"EXPAT_MALLOC_DEBUG\", 0u);\n    parser->m_alloc_tracker.maximumAmplificationFactor\n        = EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT;\n    parser->m_alloc_tracker.activationThresholdBytes\n        = EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT;\n\n    // NOTE: This initialization needs to come this early because these fields\n    //       are read by allocation tracking code\n    parser->m_parentParser = NULL;\n    parser->m_accounting.countBytesDirect = 0;\n  } else {\n    parser->m_parentParser = parentParser;\n  }\n\n  // Record XML_ParserStruct allocation we did a few lines up before\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(rootParser->m_parentParser == NULL);\n  assert(SIZE_MAX - rootParser->m_alloc_tracker.bytesAllocated >= increase);\n  rootParser->m_alloc_tracker.bytesAllocated += increase;\n\n  // Report on allocation\n  if (rootParser->m_alloc_tracker.debugLevel >= 2) {\n    if (rootParser->m_alloc_tracker.bytesAllocated\n        > rootParser->m_alloc_tracker.peakBytesAllocated) {\n      rootParser->m_alloc_tracker.peakBytesAllocated\n          = rootParser->m_alloc_tracker.bytesAllocated;\n    }\n\n    expat_heap_stat(rootParser, '+', increase,\n                    rootParser->m_alloc_tracker.bytesAllocated,\n                    rootParser->m_alloc_tracker.peakBytesAllocated, __LINE__);\n  }\n#else\n  parser->m_parentParser = NULL;\n#endif // XML_GE == 1\n\n  parser->m_buffer = NULL;\n  parser->m_bufferLim = NULL;\n\n  parser->m_attsSize = INIT_ATTS_SIZE;\n  parser->m_atts = MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));\n  if (parser->m_atts == NULL) {\n    FREE(parser, parser);\n    return NULL;\n  }\n#ifdef XML_ATTR_INFO\n  parser->m_attInfo = MALLOC(parser, parser->m_attsSize * sizeof(XML_AttrInfo));\n  if (parser->m_attInfo == NULL) {\n    FREE(parser, parser->m_atts);\n    FREE(parser, parser);\n    return NULL;\n  }\n#endif\n  parser->m_dataBuf = MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));\n  if (parser->m_dataBuf == NULL) {\n    FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n    FREE(parser, parser->m_attInfo);\n#endif\n    FREE(parser, parser);\n    return NULL;\n  }\n  parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;\n\n  if (dtd)\n    parser->m_dtd = dtd;\n  else {\n    parser->m_dtd = dtdCreate(parser);\n    if (parser->m_dtd == NULL) {\n      FREE(parser, parser->m_dataBuf);\n      FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n      FREE(parser, parser->m_attInfo);\n#endif\n      FREE(parser, parser);\n      return NULL;\n    }\n  }\n\n  parser->m_freeBindingList = NULL;\n  parser->m_freeTagList = NULL;\n  parser->m_freeInternalEntities = NULL;\n  parser->m_freeAttributeEntities = NULL;\n  parser->m_freeValueEntities = NULL;\n\n  parser->m_groupSize = 0;\n  parser->m_groupConnector = NULL;\n\n  parser->m_unknownEncodingHandler = NULL;\n  parser->m_unknownEncodingHandlerData = NULL;\n\n  parser->m_namespaceSeparator = ASCII_EXCL;\n  parser->m_ns = XML_FALSE;\n  parser->m_ns_triplets = XML_FALSE;\n\n  parser->m_nsAtts = NULL;\n  parser->m_nsAttsVersion = 0;\n  parser->m_nsAttsPower = 0;\n\n  parser->m_protocolEncodingName = NULL;\n\n  poolInit(&parser->m_tempPool, parser);\n  poolInit(&parser->m_temp2Pool, parser);\n  parserInit(parser, encodingName);\n\n  if (encodingName && ! parser->m_protocolEncodingName) {\n    if (dtd) {\n      // We need to stop the upcoming call to XML_ParserFree from happily\n      // destroying parser->m_dtd because the DTD is shared with the parent\n      // parser and the only guard that keeps XML_ParserFree from destroying\n      // parser->m_dtd is parser->m_isParamEntity but it will be set to\n      // XML_TRUE only later in XML_ExternalEntityParserCreate (or not at all).\n      parser->m_dtd = NULL;\n    }\n    XML_ParserFree(parser);\n    return NULL;\n  }\n\n  if (nameSep) {\n    parser->m_ns = XML_TRUE;\n    parser->m_internalEncoding = XmlGetInternalEncodingNS();\n    parser->m_namespaceSeparator = *nameSep;\n  } else {\n    parser->m_internalEncoding = XmlGetInternalEncoding();\n  }\n\n  return parser;\n}\n\nstatic void\nparserInit(XML_Parser parser, const XML_Char *encodingName) {\n  parser->m_processor = prologInitProcessor;\n  XmlPrologStateInit(&parser->m_prologState);\n  if (encodingName != NULL) {\n    parser->m_protocolEncodingName = copyString(encodingName, parser);\n  }\n  parser->m_curBase = NULL;\n  XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);\n  parser->m_userData = NULL;\n  parser->m_handlerArg = NULL;\n  parser->m_startElementHandler = NULL;\n  parser->m_endElementHandler = NULL;\n  parser->m_characterDataHandler = NULL;\n  parser->m_processingInstructionHandler = NULL;\n  parser->m_commentHandler = NULL;\n  parser->m_startCdataSectionHandler = NULL;\n  parser->m_endCdataSectionHandler = NULL;\n  parser->m_defaultHandler = NULL;\n  parser->m_startDoctypeDeclHandler = NULL;\n  parser->m_endDoctypeDeclHandler = NULL;\n  parser->m_unparsedEntityDeclHandler = NULL;\n  parser->m_notationDeclHandler = NULL;\n  parser->m_startNamespaceDeclHandler = NULL;\n  parser->m_endNamespaceDeclHandler = NULL;\n  parser->m_notStandaloneHandler = NULL;\n  parser->m_externalEntityRefHandler = NULL;\n  parser->m_externalEntityRefHandlerArg = parser;\n  parser->m_skippedEntityHandler = NULL;\n  parser->m_elementDeclHandler = NULL;\n  parser->m_attlistDeclHandler = NULL;\n  parser->m_entityDeclHandler = NULL;\n  parser->m_xmlDeclHandler = NULL;\n  parser->m_bufferPtr = parser->m_buffer;\n  parser->m_bufferEnd = parser->m_buffer;\n  parser->m_parseEndByteIndex = 0;\n  parser->m_parseEndPtr = NULL;\n  parser->m_partialTokenBytesBefore = 0;\n  parser->m_reparseDeferralEnabled = g_reparseDeferralEnabledDefault;\n  parser->m_lastBufferRequestSize = 0;\n  parser->m_declElementType = NULL;\n  parser->m_declAttributeId = NULL;\n  parser->m_declEntity = NULL;\n  parser->m_doctypeName = NULL;\n  parser->m_doctypeSysid = NULL;\n  parser->m_doctypePubid = NULL;\n  parser->m_declAttributeType = NULL;\n  parser->m_declNotationName = NULL;\n  parser->m_declNotationPublicId = NULL;\n  parser->m_declAttributeIsCdata = XML_FALSE;\n  parser->m_declAttributeIsId = XML_FALSE;\n  memset(&parser->m_position, 0, sizeof(POSITION));\n  parser->m_errorCode = XML_ERROR_NONE;\n  parser->m_eventPtr = NULL;\n  parser->m_eventEndPtr = NULL;\n  parser->m_positionPtr = NULL;\n  parser->m_openInternalEntities = NULL;\n  parser->m_openAttributeEntities = NULL;\n  parser->m_openValueEntities = NULL;\n  parser->m_defaultExpandInternalEntities = XML_TRUE;\n  parser->m_tagLevel = 0;\n  parser->m_tagStack = NULL;\n  parser->m_inheritedBindings = NULL;\n  parser->m_nSpecifiedAtts = 0;\n  parser->m_unknownEncodingMem = NULL;\n  parser->m_unknownEncodingRelease = NULL;\n  parser->m_unknownEncodingData = NULL;\n  parser->m_parsingStatus.parsing = XML_INITIALIZED;\n  // Reentry can only be triggered inside m_processor calls\n  parser->m_reenter = XML_FALSE;\n#ifdef XML_DTD\n  parser->m_isParamEntity = XML_FALSE;\n  parser->m_useForeignDTD = XML_FALSE;\n  parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\n#endif\n  parser->m_hash_secret_salt_128.k[0] = 0;\n  parser->m_hash_secret_salt_128.k[1] = 0;\n  parser->m_hash_secret_salt_set = XML_FALSE;\n\n#if XML_GE == 1\n  memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));\n  parser->m_accounting.debugLevel = getDebugLevel(\"EXPAT_ACCOUNTING_DEBUG\", 0u);\n  parser->m_accounting.maximumAmplificationFactor\n      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT;\n  parser->m_accounting.activationThresholdBytes\n      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT;\n\n  memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));\n  parser->m_entity_stats.debugLevel = getDebugLevel(\"EXPAT_ENTITY_DEBUG\", 0u);\n#endif\n}\n\n/* moves list of bindings to m_freeBindingList */\nstatic void FASTCALL\nmoveToFreeBindingList(XML_Parser parser, BINDING *bindings) {\n  while (bindings) {\n    BINDING *b = bindings;\n    bindings = bindings->nextTagBinding;\n    b->nextTagBinding = parser->m_freeBindingList;\n    parser->m_freeBindingList = b;\n  }\n}\n\nXML_Bool XMLCALL\nXML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {\n  TAG *tStk;\n  OPEN_INTERNAL_ENTITY *openEntityList;\n\n  if (parser == NULL)\n    return XML_FALSE;\n\n  if (parser->m_parentParser)\n    return XML_FALSE;\n  /* move m_tagStack to m_freeTagList */\n  tStk = parser->m_tagStack;\n  while (tStk) {\n    TAG *tag = tStk;\n    tStk = tStk->parent;\n    tag->parent = parser->m_freeTagList;\n    moveToFreeBindingList(parser, tag->bindings);\n    tag->bindings = NULL;\n    parser->m_freeTagList = tag;\n  }\n  /* move m_openInternalEntities to m_freeInternalEntities */\n  openEntityList = parser->m_openInternalEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeInternalEntities;\n    parser->m_freeInternalEntities = openEntity;\n  }\n  /* move m_openAttributeEntities to m_freeAttributeEntities (i.e. same task but\n   * for attributes) */\n  openEntityList = parser->m_openAttributeEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeAttributeEntities;\n    parser->m_freeAttributeEntities = openEntity;\n  }\n  /* move m_openValueEntities to m_freeValueEntities (i.e. same task but\n   * for value entities) */\n  openEntityList = parser->m_openValueEntities;\n  while (openEntityList) {\n    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;\n    openEntityList = openEntity->next;\n    openEntity->next = parser->m_freeValueEntities;\n    parser->m_freeValueEntities = openEntity;\n  }\n  moveToFreeBindingList(parser, parser->m_inheritedBindings);\n  FREE(parser, parser->m_unknownEncodingMem);\n  if (parser->m_unknownEncodingRelease)\n    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);\n  poolClear(&parser->m_tempPool);\n  poolClear(&parser->m_temp2Pool);\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n  parser->m_protocolEncodingName = NULL;\n  parserInit(parser, encodingName);\n  dtdReset(parser->m_dtd, parser);\n  return XML_TRUE;\n}\n\nstatic XML_Bool\nparserBusy(XML_Parser parser) {\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_PARSING:\n  case XML_SUSPENDED:\n    return XML_TRUE;\n  case XML_INITIALIZED:\n  case XML_FINISHED:\n  default:\n    return XML_FALSE;\n  }\n}\n\nenum XML_Status XMLCALL\nXML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  /* Block after XML_Parse()/XML_ParseBuffer() has been called.\n     XXX There's no way for the caller to determine which of the\n     XXX possible error cases caused the XML_STATUS_ERROR return.\n  */\n  if (parserBusy(parser))\n    return XML_STATUS_ERROR;\n\n  /* Get rid of any previous encoding name */\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n\n  if (encodingName == NULL)\n    /* No new encoding name */\n    parser->m_protocolEncodingName = NULL;\n  else {\n    /* Copy the new encoding name into allocated memory */\n    parser->m_protocolEncodingName = copyString(encodingName, parser);\n    if (! parser->m_protocolEncodingName)\n      return XML_STATUS_ERROR;\n  }\n  return XML_STATUS_OK;\n}\n\nXML_Parser XMLCALL\nXML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,\n                               const XML_Char *encodingName) {\n  XML_Parser parser = oldParser;\n  DTD *newDtd = NULL;\n  DTD *oldDtd;\n  XML_StartElementHandler oldStartElementHandler;\n  XML_EndElementHandler oldEndElementHandler;\n  XML_CharacterDataHandler oldCharacterDataHandler;\n  XML_ProcessingInstructionHandler oldProcessingInstructionHandler;\n  XML_CommentHandler oldCommentHandler;\n  XML_StartCdataSectionHandler oldStartCdataSectionHandler;\n  XML_EndCdataSectionHandler oldEndCdataSectionHandler;\n  XML_DefaultHandler oldDefaultHandler;\n  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;\n  XML_NotationDeclHandler oldNotationDeclHandler;\n  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;\n  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;\n  XML_NotStandaloneHandler oldNotStandaloneHandler;\n  XML_ExternalEntityRefHandler oldExternalEntityRefHandler;\n  XML_SkippedEntityHandler oldSkippedEntityHandler;\n  XML_UnknownEncodingHandler oldUnknownEncodingHandler;\n  void *oldUnknownEncodingHandlerData;\n  XML_ElementDeclHandler oldElementDeclHandler;\n  XML_AttlistDeclHandler oldAttlistDeclHandler;\n  XML_EntityDeclHandler oldEntityDeclHandler;\n  XML_XmlDeclHandler oldXmlDeclHandler;\n  ELEMENT_TYPE *oldDeclElementType;\n\n  void *oldUserData;\n  void *oldHandlerArg;\n  XML_Bool oldDefaultExpandInternalEntities;\n  XML_Parser oldExternalEntityRefHandlerArg;\n#ifdef XML_DTD\n  enum XML_ParamEntityParsing oldParamEntityParsing;\n  int oldInEntityValue;\n#endif\n  XML_Bool oldns_triplets;\n  /* Note that the new parser shares the same hash secret as the old\n     parser, so that dtdCopy and copyEntityTable can lookup values\n     from hash tables associated with either parser without us having\n     to worry which hash secrets each table has.\n  */\n  struct sipkey oldhash_secret_salt_128;\n  XML_Bool oldhash_secret_salt_set;\n  XML_Bool oldReparseDeferralEnabled;\n\n  /* Validate the oldParser parameter before we pull everything out of it */\n  if (oldParser == NULL)\n    return NULL;\n\n  /* Stash the original parser contents on the stack */\n  oldDtd = parser->m_dtd;\n  oldStartElementHandler = parser->m_startElementHandler;\n  oldEndElementHandler = parser->m_endElementHandler;\n  oldCharacterDataHandler = parser->m_characterDataHandler;\n  oldProcessingInstructionHandler = parser->m_processingInstructionHandler;\n  oldCommentHandler = parser->m_commentHandler;\n  oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;\n  oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;\n  oldDefaultHandler = parser->m_defaultHandler;\n  oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;\n  oldNotationDeclHandler = parser->m_notationDeclHandler;\n  oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;\n  oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;\n  oldNotStandaloneHandler = parser->m_notStandaloneHandler;\n  oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;\n  oldSkippedEntityHandler = parser->m_skippedEntityHandler;\n  oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;\n  oldUnknownEncodingHandlerData = parser->m_unknownEncodingHandlerData;\n  oldElementDeclHandler = parser->m_elementDeclHandler;\n  oldAttlistDeclHandler = parser->m_attlistDeclHandler;\n  oldEntityDeclHandler = parser->m_entityDeclHandler;\n  oldXmlDeclHandler = parser->m_xmlDeclHandler;\n  oldDeclElementType = parser->m_declElementType;\n\n  oldUserData = parser->m_userData;\n  oldHandlerArg = parser->m_handlerArg;\n  oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;\n  oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;\n#ifdef XML_DTD\n  oldParamEntityParsing = parser->m_paramEntityParsing;\n  oldInEntityValue = parser->m_prologState.inEntityValue;\n#endif\n  oldns_triplets = parser->m_ns_triplets;\n  /* Note that the new parser shares the same hash secret as the old\n     parser, so that dtdCopy and copyEntityTable can lookup values\n     from hash tables associated with either parser without us having\n     to worry which hash secrets each table has.\n  */\n  oldhash_secret_salt_128 = parser->m_hash_secret_salt_128;\n  oldhash_secret_salt_set = parser->m_hash_secret_salt_set;\n  oldReparseDeferralEnabled = parser->m_reparseDeferralEnabled;\n\n#ifdef XML_DTD\n  if (! context)\n    newDtd = oldDtd;\n#endif /* XML_DTD */\n\n  /* Note that the magical uses of the pre-processor to make field\n     access look more like C++ require that `parser' be overwritten\n     here.  This makes this function more painful to follow than it\n     would be otherwise.\n  */\n  if (parser->m_ns) {\n    XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};\n    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd, oldParser);\n  } else {\n    parser\n        = parserCreate(encodingName, &parser->m_mem, NULL, newDtd, oldParser);\n  }\n\n  if (! parser)\n    return NULL;\n\n  parser->m_startElementHandler = oldStartElementHandler;\n  parser->m_endElementHandler = oldEndElementHandler;\n  parser->m_characterDataHandler = oldCharacterDataHandler;\n  parser->m_processingInstructionHandler = oldProcessingInstructionHandler;\n  parser->m_commentHandler = oldCommentHandler;\n  parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;\n  parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;\n  parser->m_defaultHandler = oldDefaultHandler;\n  parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;\n  parser->m_notationDeclHandler = oldNotationDeclHandler;\n  parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;\n  parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;\n  parser->m_notStandaloneHandler = oldNotStandaloneHandler;\n  parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;\n  parser->m_skippedEntityHandler = oldSkippedEntityHandler;\n  parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;\n  parser->m_unknownEncodingHandlerData = oldUnknownEncodingHandlerData;\n  parser->m_elementDeclHandler = oldElementDeclHandler;\n  parser->m_attlistDeclHandler = oldAttlistDeclHandler;\n  parser->m_entityDeclHandler = oldEntityDeclHandler;\n  parser->m_xmlDeclHandler = oldXmlDeclHandler;\n  parser->m_declElementType = oldDeclElementType;\n  parser->m_userData = oldUserData;\n  if (oldUserData == oldHandlerArg)\n    parser->m_handlerArg = parser->m_userData;\n  else\n    parser->m_handlerArg = parser;\n  if (oldExternalEntityRefHandlerArg != oldParser)\n    parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;\n  parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;\n  parser->m_ns_triplets = oldns_triplets;\n  parser->m_hash_secret_salt_128 = oldhash_secret_salt_128;\n  parser->m_hash_secret_salt_set = oldhash_secret_salt_set;\n  parser->m_reparseDeferralEnabled = oldReparseDeferralEnabled;\n  parser->m_parentParser = oldParser;\n#ifdef XML_DTD\n  parser->m_paramEntityParsing = oldParamEntityParsing;\n  parser->m_prologState.inEntityValue = oldInEntityValue;\n  if (context) {\n#endif /* XML_DTD */\n    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, parser)\n        || ! setContext(parser, context)) {\n      XML_ParserFree(parser);\n      return NULL;\n    }\n    parser->m_processor = externalEntityInitProcessor;\n#ifdef XML_DTD\n  } else {\n    /* The DTD instance referenced by parser->m_dtd is shared between the\n       document's root parser and external PE parsers, therefore one does not\n       need to call setContext. In addition, one also *must* not call\n       setContext, because this would overwrite existing prefix->binding\n       pointers in parser->m_dtd with ones that get destroyed with the external\n       PE parser. This would leave those prefixes with dangling pointers.\n    */\n    parser->m_isParamEntity = XML_TRUE;\n    XmlPrologStateInitExternalEntity(&parser->m_prologState);\n    parser->m_processor = externalParEntInitProcessor;\n  }\n#endif /* XML_DTD */\n  return parser;\n}\n\nstatic void FASTCALL\ndestroyBindings(BINDING *bindings, XML_Parser parser) {\n  for (;;) {\n    BINDING *b = bindings;\n    if (! b)\n      break;\n    bindings = b->nextTagBinding;\n    FREE(parser, b->uri);\n    FREE(parser, b);\n  }\n}\n\nvoid XMLCALL\nXML_ParserFree(XML_Parser parser) {\n  TAG *tagList;\n  OPEN_INTERNAL_ENTITY *entityList;\n  if (parser == NULL)\n    return;\n  /* free m_tagStack and m_freeTagList */\n  tagList = parser->m_tagStack;\n  for (;;) {\n    TAG *p;\n    if (tagList == NULL) {\n      if (parser->m_freeTagList == NULL)\n        break;\n      tagList = parser->m_freeTagList;\n      parser->m_freeTagList = NULL;\n    }\n    p = tagList;\n    tagList = tagList->parent;\n    FREE(parser, p->buf.raw);\n    destroyBindings(p->bindings, parser);\n    FREE(parser, p);\n  }\n  /* free m_openInternalEntities and m_freeInternalEntities */\n  entityList = parser->m_openInternalEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeInternalEntities == NULL)\n        break;\n      entityList = parser->m_freeInternalEntities;\n      parser->m_freeInternalEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  /* free m_openAttributeEntities and m_freeAttributeEntities */\n  entityList = parser->m_openAttributeEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeAttributeEntities == NULL)\n        break;\n      entityList = parser->m_freeAttributeEntities;\n      parser->m_freeAttributeEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  /* free m_openValueEntities and m_freeValueEntities */\n  entityList = parser->m_openValueEntities;\n  for (;;) {\n    OPEN_INTERNAL_ENTITY *openEntity;\n    if (entityList == NULL) {\n      if (parser->m_freeValueEntities == NULL)\n        break;\n      entityList = parser->m_freeValueEntities;\n      parser->m_freeValueEntities = NULL;\n    }\n    openEntity = entityList;\n    entityList = entityList->next;\n    FREE(parser, openEntity);\n  }\n  destroyBindings(parser->m_freeBindingList, parser);\n  destroyBindings(parser->m_inheritedBindings, parser);\n  poolDestroy(&parser->m_tempPool);\n  poolDestroy(&parser->m_temp2Pool);\n  FREE(parser, (void *)parser->m_protocolEncodingName);\n#ifdef XML_DTD\n  /* external parameter entity parsers share the DTD structure\n     parser->m_dtd with the root parser, so we must not destroy it\n  */\n  if (! parser->m_isParamEntity && parser->m_dtd)\n#else\n  if (parser->m_dtd)\n#endif /* XML_DTD */\n    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser, parser);\n  FREE(parser, parser->m_atts);\n#ifdef XML_ATTR_INFO\n  FREE(parser, parser->m_attInfo);\n#endif\n  FREE(parser, parser->m_groupConnector);\n  // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n  //       is not being allocated with MALLOC(..) but with plain\n  //       .malloc_fcn(..).\n  parser->m_mem.free_fcn(parser->m_buffer);\n  FREE(parser, parser->m_dataBuf);\n  FREE(parser, parser->m_nsAtts);\n  FREE(parser, parser->m_unknownEncodingMem);\n  if (parser->m_unknownEncodingRelease)\n    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);\n  FREE(parser, parser);\n}\n\nvoid XMLCALL\nXML_UseParserAsHandlerArg(XML_Parser parser) {\n  if (parser != NULL)\n    parser->m_handlerArg = parser;\n}\n\nenum XML_Error XMLCALL\nXML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {\n  if (parser == NULL)\n    return XML_ERROR_INVALID_ARGUMENT;\n#ifdef XML_DTD\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;\n  parser->m_useForeignDTD = useDTD;\n  return XML_ERROR_NONE;\n#else\n  UNUSED_P(useDTD);\n  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;\n#endif\n}\n\nvoid XMLCALL\nXML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {\n  if (parser == NULL)\n    return;\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return;\n  parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;\n}\n\nvoid XMLCALL\nXML_SetUserData(XML_Parser parser, void *p) {\n  if (parser == NULL)\n    return;\n  if (parser->m_handlerArg == parser->m_userData)\n    parser->m_handlerArg = parser->m_userData = p;\n  else\n    parser->m_userData = p;\n}\n\nenum XML_Status XMLCALL\nXML_SetBase(XML_Parser parser, const XML_Char *p) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  if (p) {\n    p = poolCopyString(&parser->m_dtd->pool, p);\n    if (! p)\n      return XML_STATUS_ERROR;\n    parser->m_curBase = p;\n  } else\n    parser->m_curBase = NULL;\n  return XML_STATUS_OK;\n}\n\nconst XML_Char *XMLCALL\nXML_GetBase(XML_Parser parser) {\n  if (parser == NULL)\n    return NULL;\n  return parser->m_curBase;\n}\n\nint XMLCALL\nXML_GetSpecifiedAttributeCount(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  return parser->m_nSpecifiedAtts;\n}\n\nint XMLCALL\nXML_GetIdAttributeIndex(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  return parser->m_idAttIndex;\n}\n\n#ifdef XML_ATTR_INFO\nconst XML_AttrInfo *XMLCALL\nXML_GetAttributeInfo(XML_Parser parser) {\n  if (parser == NULL)\n    return NULL;\n  return parser->m_attInfo;\n}\n#endif\n\nvoid XMLCALL\nXML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,\n                      XML_EndElementHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startElementHandler = start;\n  parser->m_endElementHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {\n  if (parser != NULL)\n    parser->m_startElementHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {\n  if (parser != NULL)\n    parser->m_endElementHandler = end;\n}\n\nvoid XMLCALL\nXML_SetCharacterDataHandler(XML_Parser parser,\n                            XML_CharacterDataHandler handler) {\n  if (parser != NULL)\n    parser->m_characterDataHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetProcessingInstructionHandler(XML_Parser parser,\n                                    XML_ProcessingInstructionHandler handler) {\n  if (parser != NULL)\n    parser->m_processingInstructionHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {\n  if (parser != NULL)\n    parser->m_commentHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetCdataSectionHandler(XML_Parser parser,\n                           XML_StartCdataSectionHandler start,\n                           XML_EndCdataSectionHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startCdataSectionHandler = start;\n  parser->m_endCdataSectionHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartCdataSectionHandler(XML_Parser parser,\n                                XML_StartCdataSectionHandler start) {\n  if (parser != NULL)\n    parser->m_startCdataSectionHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndCdataSectionHandler(XML_Parser parser,\n                              XML_EndCdataSectionHandler end) {\n  if (parser != NULL)\n    parser->m_endCdataSectionHandler = end;\n}\n\nvoid XMLCALL\nXML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {\n  if (parser == NULL)\n    return;\n  parser->m_defaultHandler = handler;\n  parser->m_defaultExpandInternalEntities = XML_FALSE;\n}\n\nvoid XMLCALL\nXML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {\n  if (parser == NULL)\n    return;\n  parser->m_defaultHandler = handler;\n  parser->m_defaultExpandInternalEntities = XML_TRUE;\n}\n\nvoid XMLCALL\nXML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,\n                          XML_EndDoctypeDeclHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startDoctypeDeclHandler = start;\n  parser->m_endDoctypeDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartDoctypeDeclHandler(XML_Parser parser,\n                               XML_StartDoctypeDeclHandler start) {\n  if (parser != NULL)\n    parser->m_startDoctypeDeclHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {\n  if (parser != NULL)\n    parser->m_endDoctypeDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetUnparsedEntityDeclHandler(XML_Parser parser,\n                                 XML_UnparsedEntityDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_unparsedEntityDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_notationDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetNamespaceDeclHandler(XML_Parser parser,\n                            XML_StartNamespaceDeclHandler start,\n                            XML_EndNamespaceDeclHandler end) {\n  if (parser == NULL)\n    return;\n  parser->m_startNamespaceDeclHandler = start;\n  parser->m_endNamespaceDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetStartNamespaceDeclHandler(XML_Parser parser,\n                                 XML_StartNamespaceDeclHandler start) {\n  if (parser != NULL)\n    parser->m_startNamespaceDeclHandler = start;\n}\n\nvoid XMLCALL\nXML_SetEndNamespaceDeclHandler(XML_Parser parser,\n                               XML_EndNamespaceDeclHandler end) {\n  if (parser != NULL)\n    parser->m_endNamespaceDeclHandler = end;\n}\n\nvoid XMLCALL\nXML_SetNotStandaloneHandler(XML_Parser parser,\n                            XML_NotStandaloneHandler handler) {\n  if (parser != NULL)\n    parser->m_notStandaloneHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetExternalEntityRefHandler(XML_Parser parser,\n                                XML_ExternalEntityRefHandler handler) {\n  if (parser != NULL)\n    parser->m_externalEntityRefHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {\n  if (parser == NULL)\n    return;\n  if (arg)\n    parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;\n  else\n    parser->m_externalEntityRefHandlerArg = parser;\n}\n\nvoid XMLCALL\nXML_SetSkippedEntityHandler(XML_Parser parser,\n                            XML_SkippedEntityHandler handler) {\n  if (parser != NULL)\n    parser->m_skippedEntityHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetUnknownEncodingHandler(XML_Parser parser,\n                              XML_UnknownEncodingHandler handler, void *data) {\n  if (parser == NULL)\n    return;\n  parser->m_unknownEncodingHandler = handler;\n  parser->m_unknownEncodingHandlerData = data;\n}\n\nvoid XMLCALL\nXML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {\n  if (parser != NULL)\n    parser->m_elementDeclHandler = eldecl;\n}\n\nvoid XMLCALL\nXML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {\n  if (parser != NULL)\n    parser->m_attlistDeclHandler = attdecl;\n}\n\nvoid XMLCALL\nXML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_entityDeclHandler = handler;\n}\n\nvoid XMLCALL\nXML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {\n  if (parser != NULL)\n    parser->m_xmlDeclHandler = handler;\n}\n\nint XMLCALL\nXML_SetParamEntityParsing(XML_Parser parser,\n                          enum XML_ParamEntityParsing peParsing) {\n  if (parser == NULL)\n    return 0;\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(parser))\n    return 0;\n#ifdef XML_DTD\n  parser->m_paramEntityParsing = peParsing;\n  return 1;\n#else\n  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;\n#endif\n}\n\n// DEPRECATED since Expat 2.8.0.\nint XMLCALL\nXML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {\n  if (parser == NULL)\n    return 0;\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(rootParser))\n    return 0;\n\n  rootParser->m_hash_secret_salt_128.k[0] = 0;\n  rootParser->m_hash_secret_salt_128.k[1] = hash_salt;\n\n  if (hash_salt != 0) { // to remain backwards compatible\n    rootParser->m_hash_secret_salt_set = XML_TRUE;\n\n    if (sizeof(unsigned long) == 4)\n      ENTROPY_DEBUG(\"explicit(4)\", rootParser->m_hash_secret_salt_128);\n    else\n      ENTROPY_DEBUG(\"explicit(8)\", rootParser->m_hash_secret_salt_128);\n  }\n\n  return 1;\n}\n\nXML_Bool XMLCALL\nXML_SetHashSalt16Bytes(XML_Parser parser, const uint8_t entropy[16]) {\n  if (parser == NULL)\n    return XML_FALSE;\n\n  if (entropy == NULL)\n    return XML_FALSE;\n\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  /* block after XML_Parse()/XML_ParseBuffer() has been called */\n  if (parserBusy(rootParser))\n    return XML_FALSE;\n\n  sip_tokey(&(rootParser->m_hash_secret_salt_128), entropy);\n\n  rootParser->m_hash_secret_salt_set = XML_TRUE;\n\n  ENTROPY_DEBUG(\"explicit(16)\", rootParser->m_hash_secret_salt_128);\n\n  return XML_TRUE;\n}\n\nenum XML_Status XMLCALL\nXML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {\n  if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {\n    if (parser != NULL)\n      parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;\n    return XML_STATUS_ERROR;\n  }\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return XML_STATUS_ERROR;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_INITIALIZED:\n    if (parser->m_parentParser == NULL && ! startParsing(parser)) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return XML_STATUS_ERROR;\n    }\n    /* fall through */\n  default:\n    parser->m_parsingStatus.parsing = XML_PARSING;\n  }\n\n#if XML_CONTEXT_BYTES == 0\n  if (parser->m_bufferPtr == parser->m_bufferEnd) {\n    const char *end;\n    int nLeftOver;\n    enum XML_Status result;\n    /* Detect overflow (a+b > MAX <==> b > MAX-a) */\n    if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n      parser->m_processor = errorProcessor;\n      return XML_STATUS_ERROR;\n    }\n    // though this isn't a buffer request, we assume that `len` is the app's\n    // preferred buffer fill size, and therefore save it here.\n    parser->m_lastBufferRequestSize = len;\n    parser->m_parseEndByteIndex += len;\n    parser->m_positionPtr = s;\n    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;\n\n    parser->m_errorCode\n        = callProcessor(parser, s, parser->m_parseEndPtr = s + len, &end);\n\n    if (parser->m_errorCode != XML_ERROR_NONE) {\n      parser->m_eventEndPtr = parser->m_eventPtr;\n      parser->m_processor = errorProcessor;\n      return XML_STATUS_ERROR;\n    } else {\n      switch (parser->m_parsingStatus.parsing) {\n      case XML_SUSPENDED:\n        result = XML_STATUS_SUSPENDED;\n        break;\n      case XML_INITIALIZED:\n      case XML_PARSING:\n        if (isFinal) {\n          parser->m_parsingStatus.parsing = XML_FINISHED;\n          return XML_STATUS_OK;\n        }\n      /* fall through */\n      default:\n        result = XML_STATUS_OK;\n      }\n    }\n\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,\n                      &parser->m_position);\n    nLeftOver = s + len - end;\n    if (nLeftOver) {\n      // Back up and restore the parsing status to avoid XML_ERROR_SUSPENDED\n      // (and XML_ERROR_FINISHED) from XML_GetBuffer.\n      const enum XML_Parsing originalStatus = parser->m_parsingStatus.parsing;\n      parser->m_parsingStatus.parsing = XML_PARSING;\n      void *const temp = XML_GetBuffer(parser, nLeftOver);\n      parser->m_parsingStatus.parsing = originalStatus;\n      // GetBuffer may have overwritten this, but we want to remember what the\n      // app requested, not how many bytes were left over after parsing.\n      parser->m_lastBufferRequestSize = len;\n      if (temp == NULL) {\n        // NOTE: parser->m_errorCode has already been set by XML_GetBuffer().\n        parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n        parser->m_processor = errorProcessor;\n        return XML_STATUS_ERROR;\n      }\n      // Since we know that the buffer was empty and XML_CONTEXT_BYTES is 0, we\n      // don't have any data to preserve, and can copy straight into the start\n      // of the buffer rather than the GetBuffer return pointer (which may be\n      // pointing further into the allocated buffer).\n      memcpy(parser->m_buffer, end, nLeftOver);\n    }\n    parser->m_bufferPtr = parser->m_buffer;\n    parser->m_bufferEnd = parser->m_buffer + nLeftOver;\n    parser->m_positionPtr = parser->m_bufferPtr;\n    parser->m_parseEndPtr = parser->m_bufferEnd;\n    parser->m_eventPtr = parser->m_bufferPtr;\n    parser->m_eventEndPtr = parser->m_bufferPtr;\n    return result;\n  }\n#endif /* XML_CONTEXT_BYTES == 0 */\n  void *buff = XML_GetBuffer(parser, len);\n  if (buff == NULL)\n    return XML_STATUS_ERROR;\n  if (len > 0) {\n    assert(s != NULL); // make sure s==NULL && len!=0 was rejected above\n    memcpy(buff, s, len);\n  }\n  return XML_ParseBuffer(parser, len, isFinal);\n}\n\nenum XML_Status XMLCALL\nXML_ParseBuffer(XML_Parser parser, int len, int isFinal) {\n  const char *start;\n  enum XML_Status result = XML_STATUS_OK;\n\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n\n  if (len < 0) {\n    parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;\n    return XML_STATUS_ERROR;\n  }\n\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return XML_STATUS_ERROR;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_INITIALIZED:\n    /* Has someone called XML_GetBuffer successfully before? */\n    if (! parser->m_bufferPtr) {\n      parser->m_errorCode = XML_ERROR_NO_BUFFER;\n      return XML_STATUS_ERROR;\n    }\n\n    if (parser->m_parentParser == NULL && ! startParsing(parser)) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return XML_STATUS_ERROR;\n    }\n    /* fall through */\n  default:\n    parser->m_parsingStatus.parsing = XML_PARSING;\n  }\n\n  start = parser->m_bufferPtr;\n  parser->m_positionPtr = start;\n  parser->m_bufferEnd += len;\n  parser->m_parseEndPtr = parser->m_bufferEnd;\n  parser->m_parseEndByteIndex += len;\n  parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;\n\n  parser->m_errorCode = callProcessor(parser, start, parser->m_parseEndPtr,\n                                      &parser->m_bufferPtr);\n\n  if (parser->m_errorCode != XML_ERROR_NONE) {\n    parser->m_eventEndPtr = parser->m_eventPtr;\n    parser->m_processor = errorProcessor;\n    return XML_STATUS_ERROR;\n  } else {\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      result = XML_STATUS_SUSPENDED;\n      break;\n    case XML_INITIALIZED:\n    case XML_PARSING:\n      if (isFinal) {\n        parser->m_parsingStatus.parsing = XML_FINISHED;\n        return result;\n      }\n    default:; /* should not happen */\n    }\n  }\n\n  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                    parser->m_bufferPtr, &parser->m_position);\n  parser->m_positionPtr = parser->m_bufferPtr;\n  return result;\n}\n\nvoid *XMLCALL\nXML_GetBuffer(XML_Parser parser, int len) {\n  if (parser == NULL)\n    return NULL;\n  if (len < 0) {\n    parser->m_errorCode = XML_ERROR_NO_MEMORY;\n    return NULL;\n  }\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_SUSPENDED:\n    parser->m_errorCode = XML_ERROR_SUSPENDED;\n    return NULL;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return NULL;\n  default:;\n  }\n\n  // whether or not the request succeeds, `len` seems to be the app's preferred\n  // buffer fill size; remember it.\n  parser->m_lastBufferRequestSize = len;\n  if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)\n      || parser->m_buffer == NULL) {\n#if XML_CONTEXT_BYTES > 0\n    int keep;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    /* Do not invoke signed arithmetic overflow: */\n    int neededSize = (int)((unsigned)len\n                           + (unsigned)EXPAT_SAFE_PTR_DIFF(\n                               parser->m_bufferEnd, parser->m_bufferPtr));\n    if (neededSize < 0) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return NULL;\n    }\n#if XML_CONTEXT_BYTES > 0\n    keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);\n    if (keep > XML_CONTEXT_BYTES)\n      keep = XML_CONTEXT_BYTES;\n    /* Detect and prevent integer overflow */\n    if (keep > INT_MAX - neededSize) {\n      parser->m_errorCode = XML_ERROR_NO_MEMORY;\n      return NULL;\n    }\n    neededSize += keep;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    if (parser->m_buffer && parser->m_bufferPtr\n        && neededSize\n               <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {\n#if XML_CONTEXT_BYTES > 0\n      if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {\n        int offset\n            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)\n              - keep;\n        /* The buffer pointers cannot be NULL here; we have at least some bytes\n         * in the buffer */\n        memmove(parser->m_buffer, &parser->m_buffer[offset],\n                parser->m_bufferEnd - parser->m_bufferPtr + keep);\n        parser->m_bufferEnd -= offset;\n        parser->m_bufferPtr -= offset;\n      }\n#else\n      memmove(parser->m_buffer, parser->m_bufferPtr,\n              EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));\n      parser->m_bufferEnd\n          = parser->m_buffer\n            + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);\n      parser->m_bufferPtr = parser->m_buffer;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    } else {\n      char *newBuf;\n      int bufferSize\n          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer);\n      if (bufferSize == 0)\n        bufferSize = INIT_BUFFER_SIZE;\n      do {\n        /* Do not invoke signed arithmetic overflow: */\n        bufferSize = (int)(2U * (unsigned)bufferSize);\n      } while (bufferSize < neededSize && bufferSize > 0);\n      if (bufferSize <= 0) {\n        parser->m_errorCode = XML_ERROR_NO_MEMORY;\n        return NULL;\n      }\n      // NOTE: We are avoiding MALLOC(..) here to leave limiting\n      //       the input size to the application using Expat.\n      newBuf = parser->m_mem.malloc_fcn(bufferSize);\n      if (newBuf == NULL) {\n        parser->m_errorCode = XML_ERROR_NO_MEMORY;\n        return NULL;\n      }\n      parser->m_bufferLim = newBuf + bufferSize;\n#if XML_CONTEXT_BYTES > 0\n      if (parser->m_bufferPtr) {\n        memcpy(newBuf, &parser->m_bufferPtr[-keep],\n               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)\n                   + keep);\n        // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n        //       is not being allocated with MALLOC(..) but with plain\n        //       .malloc_fcn(..).\n        parser->m_mem.free_fcn(parser->m_buffer);\n        parser->m_buffer = newBuf;\n        parser->m_bufferEnd\n            = parser->m_buffer\n              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)\n              + keep;\n        parser->m_bufferPtr = parser->m_buffer + keep;\n      } else {\n        /* This must be a brand new buffer with no data in it yet */\n        parser->m_bufferEnd = newBuf;\n        parser->m_bufferPtr = parser->m_buffer = newBuf;\n      }\n#else\n      if (parser->m_bufferPtr) {\n        memcpy(newBuf, parser->m_bufferPtr,\n               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));\n        // NOTE: We are avoiding FREE(..) here because parser->m_buffer\n        //       is not being allocated with MALLOC(..) but with plain\n        //       .malloc_fcn(..).\n        parser->m_mem.free_fcn(parser->m_buffer);\n        parser->m_bufferEnd\n            = newBuf\n              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);\n      } else {\n        /* This must be a brand new buffer with no data in it yet */\n        parser->m_bufferEnd = newBuf;\n      }\n      parser->m_bufferPtr = parser->m_buffer = newBuf;\n#endif /* XML_CONTEXT_BYTES > 0 */\n    }\n    parser->m_eventPtr = parser->m_eventEndPtr = NULL;\n    parser->m_positionPtr = NULL;\n  }\n  return parser->m_bufferEnd;\n}\n\nstatic void\ntriggerReenter(XML_Parser parser) {\n  parser->m_reenter = XML_TRUE;\n}\n\nenum XML_Status XMLCALL\nXML_StopParser(XML_Parser parser, XML_Bool resumable) {\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  switch (parser->m_parsingStatus.parsing) {\n  case XML_INITIALIZED:\n    parser->m_errorCode = XML_ERROR_NOT_STARTED;\n    return XML_STATUS_ERROR;\n  case XML_SUSPENDED:\n    if (resumable) {\n      parser->m_errorCode = XML_ERROR_SUSPENDED;\n      return XML_STATUS_ERROR;\n    }\n    parser->m_parsingStatus.parsing = XML_FINISHED;\n    break;\n  case XML_FINISHED:\n    parser->m_errorCode = XML_ERROR_FINISHED;\n    return XML_STATUS_ERROR;\n  case XML_PARSING:\n    if (resumable) {\n#ifdef XML_DTD\n      if (parser->m_isParamEntity) {\n        parser->m_errorCode = XML_ERROR_SUSPEND_PE;\n        return XML_STATUS_ERROR;\n      }\n#endif\n      parser->m_parsingStatus.parsing = XML_SUSPENDED;\n    } else\n      parser->m_parsingStatus.parsing = XML_FINISHED;\n    break;\n  default:\n    assert(0);\n  }\n  return XML_STATUS_OK;\n}\n\nenum XML_Status XMLCALL\nXML_ResumeParser(XML_Parser parser) {\n  enum XML_Status result = XML_STATUS_OK;\n\n  if (parser == NULL)\n    return XML_STATUS_ERROR;\n  if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {\n    parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;\n    return XML_STATUS_ERROR;\n  }\n  parser->m_parsingStatus.parsing = XML_PARSING;\n\n  parser->m_errorCode = callProcessor(\n      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);\n\n  if (parser->m_errorCode != XML_ERROR_NONE) {\n    parser->m_eventEndPtr = parser->m_eventPtr;\n    parser->m_processor = errorProcessor;\n    return XML_STATUS_ERROR;\n  } else {\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      result = XML_STATUS_SUSPENDED;\n      break;\n    case XML_INITIALIZED:\n    case XML_PARSING:\n      if (parser->m_parsingStatus.finalBuffer) {\n        parser->m_parsingStatus.parsing = XML_FINISHED;\n        return result;\n      }\n    default:;\n    }\n  }\n\n  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                    parser->m_bufferPtr, &parser->m_position);\n  parser->m_positionPtr = parser->m_bufferPtr;\n  return result;\n}\n\nvoid XMLCALL\nXML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {\n  if (parser == NULL)\n    return;\n  assert(status != NULL);\n  *status = parser->m_parsingStatus;\n}\n\nenum XML_Error XMLCALL\nXML_GetErrorCode(XML_Parser parser) {\n  if (parser == NULL)\n    return XML_ERROR_INVALID_ARGUMENT;\n  return parser->m_errorCode;\n}\n\nXML_Index XMLCALL\nXML_GetCurrentByteIndex(XML_Parser parser) {\n  if (parser == NULL)\n    return -1;\n  if (parser->m_eventPtr)\n    return (XML_Index)(parser->m_parseEndByteIndex\n                       - (parser->m_parseEndPtr - parser->m_eventPtr));\n  return -1;\n}\n\nint XMLCALL\nXML_GetCurrentByteCount(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventEndPtr && parser->m_eventPtr)\n    return (int)(parser->m_eventEndPtr - parser->m_eventPtr);\n  return 0;\n}\n\nconst char *XMLCALL\nXML_GetInputContext(XML_Parser parser, int *offset, int *size) {\n#if XML_CONTEXT_BYTES > 0\n  if (parser == NULL)\n    return NULL;\n  if (parser->m_eventPtr && parser->m_buffer) {\n    if (offset != NULL)\n      *offset = (int)(parser->m_eventPtr - parser->m_buffer);\n    if (size != NULL)\n      *size = (int)(parser->m_bufferEnd - parser->m_buffer);\n    return parser->m_buffer;\n  }\n#else\n  (void)parser;\n  (void)offset;\n  (void)size;\n#endif /* XML_CONTEXT_BYTES > 0 */\n  return (const char *)0;\n}\n\nXML_Size XMLCALL\nXML_GetCurrentLineNumber(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                      parser->m_eventPtr, &parser->m_position);\n    parser->m_positionPtr = parser->m_eventPtr;\n  }\n  return parser->m_position.lineNumber + 1;\n}\n\nXML_Size XMLCALL\nXML_GetCurrentColumnNumber(XML_Parser parser) {\n  if (parser == NULL)\n    return 0;\n  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {\n    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,\n                      parser->m_eventPtr, &parser->m_position);\n    parser->m_positionPtr = parser->m_eventPtr;\n  }\n  return parser->m_position.columnNumber;\n}\n\nvoid XMLCALL\nXML_FreeContentModel(XML_Parser parser, XML_Content *model) {\n  if (parser == NULL)\n    return;\n\n  // NOTE: We are avoiding FREE(..) here because the content model\n  //       has been created using plain .malloc_fcn(..) rather than MALLOC(..).\n  parser->m_mem.free_fcn(model);\n}\n\nvoid *XMLCALL\nXML_MemMalloc(XML_Parser parser, size_t size) {\n  if (parser == NULL)\n    return NULL;\n\n  // NOTE: We are avoiding MALLOC(..) here to not include\n  //       user allocations with allocation tracking and limiting.\n  return parser->m_mem.malloc_fcn(size);\n}\n\nvoid *XMLCALL\nXML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {\n  if (parser == NULL)\n    return NULL;\n\n  // NOTE: We are avoiding REALLOC(..) here to not include\n  //       user allocations with allocation tracking and limiting.\n  return parser->m_mem.realloc_fcn(ptr, size);\n}\n\nvoid XMLCALL\nXML_MemFree(XML_Parser parser, void *ptr) {\n  if (parser == NULL)\n    return;\n\n  // NOTE: We are avoiding FREE(..) here because XML_MemMalloc and\n  //       XML_MemRealloc are not using MALLOC(..) and REALLOC(..)\n  //       but plain .malloc_fcn(..) and .realloc_fcn(..), internally.\n  parser->m_mem.free_fcn(ptr);\n}\n\nvoid XMLCALL\nXML_DefaultCurrent(XML_Parser parser) {\n  if (parser == NULL)\n    return;\n  if (parser->m_defaultHandler) {\n    if (parser->m_openInternalEntities)\n      reportDefault(parser, parser->m_internalEncoding,\n                    parser->m_openInternalEntities->internalEventPtr,\n                    parser->m_openInternalEntities->internalEventEndPtr);\n    else\n      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,\n                    parser->m_eventEndPtr);\n  }\n}\n\nconst XML_LChar *XMLCALL\nXML_ErrorString(enum XML_Error code) {\n  switch (code) {\n  case XML_ERROR_NONE:\n    return NULL;\n  case XML_ERROR_NO_MEMORY:\n    return XML_L(\"out of memory\");\n  case XML_ERROR_SYNTAX:\n    return XML_L(\"syntax error\");\n  case XML_ERROR_NO_ELEMENTS:\n    return XML_L(\"no element found\");\n  case XML_ERROR_INVALID_TOKEN:\n    return XML_L(\"not well-formed (invalid token)\");\n  case XML_ERROR_UNCLOSED_TOKEN:\n    return XML_L(\"unclosed token\");\n  case XML_ERROR_PARTIAL_CHAR:\n    return XML_L(\"partial character\");\n  case XML_ERROR_TAG_MISMATCH:\n    return XML_L(\"mismatched tag\");\n  case XML_ERROR_DUPLICATE_ATTRIBUTE:\n    return XML_L(\"duplicate attribute\");\n  case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:\n    return XML_L(\"junk after document element\");\n  case XML_ERROR_PARAM_ENTITY_REF:\n    return XML_L(\"illegal parameter entity reference\");\n  case XML_ERROR_UNDEFINED_ENTITY:\n    return XML_L(\"undefined entity\");\n  case XML_ERROR_RECURSIVE_ENTITY_REF:\n    return XML_L(\"recursive entity reference\");\n  case XML_ERROR_ASYNC_ENTITY:\n    return XML_L(\"asynchronous entity\");\n  case XML_ERROR_BAD_CHAR_REF:\n    return XML_L(\"reference to invalid character number\");\n  case XML_ERROR_BINARY_ENTITY_REF:\n    return XML_L(\"reference to binary entity\");\n  case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:\n    return XML_L(\"reference to external entity in attribute\");\n  case XML_ERROR_MISPLACED_XML_PI:\n    return XML_L(\"XML or text declaration not at start of entity\");\n  case XML_ERROR_UNKNOWN_ENCODING:\n    return XML_L(\"unknown encoding\");\n  case XML_ERROR_INCORRECT_ENCODING:\n    return XML_L(\"encoding specified in XML declaration is incorrect\");\n  case XML_ERROR_UNCLOSED_CDATA_SECTION:\n    return XML_L(\"unclosed CDATA section\");\n  case XML_ERROR_EXTERNAL_ENTITY_HANDLING:\n    return XML_L(\"error in processing external entity reference\");\n  case XML_ERROR_NOT_STANDALONE:\n    return XML_L(\"document is not standalone\");\n  case XML_ERROR_UNEXPECTED_STATE:\n    return XML_L(\"unexpected parser state - please send a bug report\");\n  case XML_ERROR_ENTITY_DECLARED_IN_PE:\n    return XML_L(\"entity declared in parameter entity\");\n  case XML_ERROR_FEATURE_REQUIRES_XML_DTD:\n    return XML_L(\"requested feature requires XML_DTD support in Expat\");\n  case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:\n    return XML_L(\"cannot change setting once parsing has begun\");\n  /* Added in 1.95.7. */\n  case XML_ERROR_UNBOUND_PREFIX:\n    return XML_L(\"unbound prefix\");\n  /* Added in 1.95.8. */\n  case XML_ERROR_UNDECLARING_PREFIX:\n    return XML_L(\"must not undeclare prefix\");\n  case XML_ERROR_INCOMPLETE_PE:\n    return XML_L(\"incomplete markup in parameter entity\");\n  case XML_ERROR_XML_DECL:\n    return XML_L(\"XML declaration not well-formed\");\n  case XML_ERROR_TEXT_DECL:\n    return XML_L(\"text declaration not well-formed\");\n  case XML_ERROR_PUBLICID:\n    return XML_L(\"illegal character(s) in public id\");\n  case XML_ERROR_SUSPENDED:\n    return XML_L(\"parser suspended\");\n  case XML_ERROR_NOT_SUSPENDED:\n    return XML_L(\"parser not suspended\");\n  case XML_ERROR_ABORTED:\n    return XML_L(\"parsing aborted\");\n  case XML_ERROR_FINISHED:\n    return XML_L(\"parsing finished\");\n  case XML_ERROR_SUSPEND_PE:\n    return XML_L(\"cannot suspend in external parameter entity\");\n  /* Added in 2.0.0. */\n  case XML_ERROR_RESERVED_PREFIX_XML:\n    return XML_L(\n        \"reserved prefix (xml) must not be undeclared or bound to another namespace name\");\n  case XML_ERROR_RESERVED_PREFIX_XMLNS:\n    return XML_L(\"reserved prefix (xmlns) must not be declared or undeclared\");\n  case XML_ERROR_RESERVED_NAMESPACE_URI:\n    return XML_L(\n        \"prefix must not be bound to one of the reserved namespace names\");\n  /* Added in 2.2.5. */\n  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */\n    return XML_L(\"invalid argument\");\n    /* Added in 2.3.0. */\n  case XML_ERROR_NO_BUFFER:\n    return XML_L(\n        \"a successful prior call to function XML_GetBuffer is required\");\n  /* Added in 2.4.0. */\n  case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:\n    return XML_L(\n        \"limit on input amplification factor (from DTD and entities) breached\");\n  /* Added in 2.6.4. */\n  case XML_ERROR_NOT_STARTED:\n    return XML_L(\"parser not started\");\n  }\n  return NULL;\n}\n\nconst XML_LChar *XMLCALL\nXML_ExpatVersion(void) {\n  /* V1 is used to string-ize the version number. However, it would\n     string-ize the actual version macro *names* unless we get them\n     substituted before being passed to V1. CPP is defined to expand\n     a macro, then rescan for more expansions. Thus, we use V2 to expand\n     the version macros, then CPP will expand the resulting V1() macro\n     with the correct numerals. */\n  /* ### I'm assuming cpp is portable in this respect... */\n\n#define V1(a, b, c) XML_L(#a) XML_L(\".\") XML_L(#b) XML_L(\".\") XML_L(#c)\n#define V2(a, b, c) XML_L(\"expat_\") V1(a, b, c)\n\n  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);\n\n#undef V1\n#undef V2\n}\n\nXML_Expat_Version XMLCALL\nXML_ExpatVersionInfo(void) {\n  XML_Expat_Version version;\n\n  version.major = XML_MAJOR_VERSION;\n  version.minor = XML_MINOR_VERSION;\n  version.micro = XML_MICRO_VERSION;\n\n  return version;\n}\n\nconst XML_Feature *XMLCALL\nXML_GetFeatureList(void) {\n  static const XML_Feature features[] = {\n      {XML_FEATURE_SIZEOF_XML_CHAR, XML_L(\"sizeof(XML_Char)\"),\n       sizeof(XML_Char)},\n      {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L(\"sizeof(XML_LChar)\"),\n       sizeof(XML_LChar)},\n#ifdef XML_UNICODE\n      {XML_FEATURE_UNICODE, XML_L(\"XML_UNICODE\"), 0},\n#endif\n#ifdef XML_UNICODE_WCHAR_T\n      {XML_FEATURE_UNICODE_WCHAR_T, XML_L(\"XML_UNICODE_WCHAR_T\"), 0},\n#endif\n#ifdef XML_DTD\n      {XML_FEATURE_DTD, XML_L(\"XML_DTD\"), 0},\n#endif\n#if XML_CONTEXT_BYTES > 0\n      {XML_FEATURE_CONTEXT_BYTES, XML_L(\"XML_CONTEXT_BYTES\"),\n       XML_CONTEXT_BYTES},\n#endif\n#ifdef XML_MIN_SIZE\n      {XML_FEATURE_MIN_SIZE, XML_L(\"XML_MIN_SIZE\"), 0},\n#endif\n#ifdef XML_NS\n      {XML_FEATURE_NS, XML_L(\"XML_NS\"), 0},\n#endif\n#ifdef XML_LARGE_SIZE\n      {XML_FEATURE_LARGE_SIZE, XML_L(\"XML_LARGE_SIZE\"), 0},\n#endif\n#ifdef XML_ATTR_INFO\n      {XML_FEATURE_ATTR_INFO, XML_L(\"XML_ATTR_INFO\"), 0},\n#endif\n#if XML_GE == 1\n      /* Added in Expat 2.4.0 for XML_DTD defined and\n       * added in Expat 2.6.0 for XML_GE == 1. */\n      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,\n       XML_L(\"XML_BLAP_MAX_AMP\"),\n       (long int)\n           EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},\n      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,\n       XML_L(\"XML_BLAP_ACT_THRES\"),\n       EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},\n      /* Added in Expat 2.6.0. */\n      {XML_FEATURE_GE, XML_L(\"XML_GE\"), 0},\n      /* Added in Expat 2.7.2. */\n      {XML_FEATURE_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT,\n       XML_L(\"XML_AT_MAX_AMP\"),\n       (long int)EXPAT_ALLOC_TRACKER_MAXIMUM_AMPLIFICATION_DEFAULT},\n      {XML_FEATURE_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT,\n       XML_L(\"XML_AT_ACT_THRES\"),\n       (long int)EXPAT_ALLOC_TRACKER_ACTIVATION_THRESHOLD_DEFAULT},\n#endif\n      {XML_FEATURE_END, NULL, 0}};\n\n  return features;\n}\n\n#if XML_GE == 1\nXML_Bool XMLCALL\nXML_SetBillionLaughsAttackProtectionMaximumAmplification(\n    XML_Parser parser, float maximumAmplificationFactor) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)\n      || isnan(maximumAmplificationFactor)\n      || (maximumAmplificationFactor < 1.0f)) {\n    return XML_FALSE;\n  }\n  parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetBillionLaughsAttackProtectionActivationThreshold(\n    XML_Parser parser, unsigned long long activationThresholdBytes) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)) {\n    return XML_FALSE;\n  }\n  parser->m_accounting.activationThresholdBytes = activationThresholdBytes;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetAllocTrackerMaximumAmplification(XML_Parser parser,\n                                        float maximumAmplificationFactor) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)\n      || isnan(maximumAmplificationFactor)\n      || (maximumAmplificationFactor < 1.0f)) {\n    return XML_FALSE;\n  }\n  parser->m_alloc_tracker.maximumAmplificationFactor\n      = maximumAmplificationFactor;\n  return XML_TRUE;\n}\n\nXML_Bool XMLCALL\nXML_SetAllocTrackerActivationThreshold(\n    XML_Parser parser, unsigned long long activationThresholdBytes) {\n  if ((parser == NULL) || (parser->m_parentParser != NULL)) {\n    return XML_FALSE;\n  }\n  parser->m_alloc_tracker.activationThresholdBytes = activationThresholdBytes;\n  return XML_TRUE;\n}\n#endif /* XML_GE == 1 */\n\nXML_Bool XMLCALL\nXML_SetReparseDeferralEnabled(XML_Parser parser, XML_Bool enabled) {\n  if (parser != NULL && (enabled == XML_TRUE || enabled == XML_FALSE)) {\n    parser->m_reparseDeferralEnabled = enabled;\n    return XML_TRUE;\n  }\n  return XML_FALSE;\n}\n\n/* Initially tag->rawName always points into the parse buffer;\n   for those TAG instances opened while the current parse buffer was\n   processed, and not yet closed, we need to store tag->rawName in a more\n   permanent location, since the parse buffer is about to be discarded.\n*/\nstatic XML_Bool\nstoreRawNames(XML_Parser parser) {\n  TAG *tag = parser->m_tagStack;\n  while (tag) {\n    size_t bufSize;\n    size_t nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);\n    size_t rawNameLen;\n    char *rawNameBuf = tag->buf.raw + nameLen;\n    /* Stop if already stored.  Since m_tagStack is a stack, we can stop\n       at the first entry that has already been copied; everything\n       below it in the stack is already been accounted for in a\n       previous call to this function.\n    */\n    if (tag->rawName == rawNameBuf)\n      break;\n    /* For reuse purposes we need to ensure that the\n       size of tag->buf is a multiple of sizeof(XML_Char).\n    */\n    rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char));\n    /* Detect and prevent integer overflow. */\n    if (rawNameLen > (size_t)INT_MAX - nameLen)\n      return XML_FALSE;\n    bufSize = nameLen + rawNameLen;\n    if (bufSize > (size_t)(tag->bufEnd - tag->buf.raw)) {\n      char *temp = REALLOC(parser, tag->buf.raw, bufSize);\n      if (temp == NULL)\n        return XML_FALSE;\n      /* if tag->name.str points to tag->buf.str (only when namespace\n         processing is off) then we have to update it\n      */\n      if (tag->name.str == tag->buf.str)\n        tag->name.str = (XML_Char *)temp;\n      /* if tag->name.localPart is set (when namespace processing is on)\n         then update it as well, since it will always point into tag->buf\n      */\n      if (tag->name.localPart)\n        tag->name.localPart\n            = (XML_Char *)temp + (tag->name.localPart - tag->buf.str);\n      tag->buf.raw = temp;\n      tag->bufEnd = temp + bufSize;\n      rawNameBuf = temp + nameLen;\n    }\n    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);\n    tag->rawName = rawNameBuf;\n    tag = tag->parent;\n  }\n  return XML_TRUE;\n}\n\nstatic enum XML_Error PTRCALL\ncontentProcessor(XML_Parser parser, const char *start, const char *end,\n                 const char **endPtr) {\n  enum XML_Error result = doContent(\n      parser, parser->m_parentParser ? 1 : 0, parser->m_encoding, start, end,\n      endPtr, (XML_Bool)! parser->m_parsingStatus.finalBuffer,\n      XML_ACCOUNT_DIRECT);\n  if (result == XML_ERROR_NONE) {\n    if (! storeRawNames(parser))\n      return XML_ERROR_NO_MEMORY;\n  }\n  return result;\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor(XML_Parser parser, const char *start,\n                            const char *end, const char **endPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n  parser->m_processor = externalEntityInitProcessor2;\n  return externalEntityInitProcessor2(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor2(XML_Parser parser, const char *start,\n                             const char *end, const char **endPtr) {\n  const char *next = start; /* XmlContentTok doesn't always set the last arg */\n  int tok = XmlContentTok(parser->m_encoding, start, end, &next);\n  switch (tok) {\n  case XML_TOK_BOM:\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif /* XML_GE == 1 */\n\n    /* If we are at the end of the buffer, this would cause the next stage,\n       i.e. externalEntityInitProcessor3, to pass control directly to\n       doContent (by detecting XML_TOK_NONE) without processing any xml text\n       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.\n    */\n    if (next == end && ! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = next;\n      return XML_ERROR_NONE;\n    }\n    start = next;\n    break;\n  case XML_TOK_PARTIAL:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    parser->m_eventPtr = start;\n    return XML_ERROR_UNCLOSED_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    parser->m_eventPtr = start;\n    return XML_ERROR_PARTIAL_CHAR;\n  }\n  parser->m_processor = externalEntityInitProcessor3;\n  return externalEntityInitProcessor3(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityInitProcessor3(XML_Parser parser, const char *start,\n                             const char *end, const char **endPtr) {\n  int tok;\n  const char *next = start; /* XmlContentTok doesn't always set the last arg */\n  parser->m_eventPtr = start;\n  tok = XmlContentTok(parser->m_encoding, start, end, &next);\n  /* Note: These bytes are accounted later in:\n           - processXmlDecl\n           - externalEntityContentProcessor\n  */\n  parser->m_eventEndPtr = next;\n\n  switch (tok) {\n  case XML_TOK_XML_DECL: {\n    enum XML_Error result;\n    result = processXmlDecl(parser, 1, start, next);\n    if (result != XML_ERROR_NONE)\n      return result;\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *endPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n      /* Fall through */\n    default:\n      start = next;\n    }\n  } break;\n  case XML_TOK_PARTIAL:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_UNCLOSED_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (! parser->m_parsingStatus.finalBuffer) {\n      *endPtr = start;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_PARTIAL_CHAR;\n  }\n  parser->m_processor = externalEntityContentProcessor;\n  parser->m_tagLevel = 1;\n  return externalEntityContentProcessor(parser, start, end, endPtr);\n}\n\nstatic enum XML_Error PTRCALL\nexternalEntityContentProcessor(XML_Parser parser, const char *start,\n                               const char *end, const char **endPtr) {\n  enum XML_Error result\n      = doContent(parser, 1, parser->m_encoding, start, end, endPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer,\n                  XML_ACCOUNT_ENTITY_EXPANSION);\n  if (result == XML_ERROR_NONE) {\n    if (! storeRawNames(parser))\n      return XML_ERROR_NO_MEMORY;\n  }\n  return result;\n}\n\nstatic enum XML_Error\ndoContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,\n          const char *s, const char *end, const char **nextPtr,\n          XML_Bool haveMore, enum XML_Account account) {\n  /* save one level of indirection */\n  DTD *const dtd = parser->m_dtd;\n\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n  *eventPP = s;\n\n  for (;;) {\n    const char *next = s; /* XmlContentTok doesn't always set the last arg */\n    int tok = XmlContentTok(enc, s, end, &next);\n#if XML_GE == 1\n    const char *accountAfter\n        = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR))\n              ? (haveMore ? s /* i.e. 0 bytes */ : end)\n              : next;\n    if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,\n                                  account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    *eventEndPP = next;\n    switch (tok) {\n    case XML_TOK_TRAILING_CR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      *eventEndPP = end;\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, end);\n      /* We are at the end of the final buffer, should we check for\n         XML_SUSPENDED, XML_FINISHED?\n      */\n      if (startTagLevel == 0)\n        return XML_ERROR_NO_ELEMENTS;\n      if (parser->m_tagLevel != startTagLevel)\n        return XML_ERROR_ASYNC_ENTITY;\n      *nextPtr = end;\n      return XML_ERROR_NONE;\n    case XML_TOK_NONE:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      if (startTagLevel > 0) {\n        if (parser->m_tagLevel != startTagLevel)\n          return XML_ERROR_ASYNC_ENTITY;\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_NO_ELEMENTS;\n    case XML_TOK_INVALID:\n      *eventPP = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_ENTITY_REF: {\n      const XML_Char *name;\n      ENTITY *entity;\n      XML_Char ch = (XML_Char)XmlPredefinedEntityName(\n          enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);\n      if (ch) {\n#if XML_GE == 1\n        /* NOTE: We are replacing 4-6 characters original input for 1 character\n         *       so there is no amplification and hence recording without\n         *       protection. */\n        accountingDiffTolerated(parser, tok, (char *)&ch,\n                                ((char *)&ch) + sizeof(XML_Char), __LINE__,\n                                XML_ACCOUNT_ENTITY_EXPANSION);\n#endif /* XML_GE == 1 */\n        if (parser->m_characterDataHandler)\n          parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);\n        else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        break;\n      }\n      name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                             next - enc->minBytesPerChar);\n      if (! name)\n        return XML_ERROR_NO_MEMORY;\n      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);\n      poolDiscard(&dtd->pool);\n      /* First, determine if a check for an existing declaration is needed;\n         if yes, check that the entity exists, and that it is internal,\n         otherwise call the skipped entity or default handler.\n      */\n      if (! dtd->hasParamEntityRefs || dtd->standalone) {\n        if (! entity)\n          return XML_ERROR_UNDEFINED_ENTITY;\n        else if (! entity->is_internal)\n          return XML_ERROR_ENTITY_DECLARED_IN_PE;\n      } else if (! entity) {\n        if (parser->m_skippedEntityHandler)\n          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n        else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        break;\n      }\n      if (entity->open)\n        return XML_ERROR_RECURSIVE_ENTITY_REF;\n      if (entity->notation)\n        return XML_ERROR_BINARY_ENTITY_REF;\n      if (entity->textPtr) {\n        enum XML_Error result;\n        if (! parser->m_defaultExpandInternalEntities) {\n          if (parser->m_skippedEntityHandler)\n            parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,\n                                           0);\n          else if (parser->m_defaultHandler)\n            reportDefault(parser, enc, s, next);\n          break;\n        }\n        result = processEntity(parser, entity, XML_FALSE, ENTITY_INTERNAL);\n        if (result != XML_ERROR_NONE)\n          return result;\n      } else if (parser->m_externalEntityRefHandler) {\n        const XML_Char *context;\n        entity->open = XML_TRUE;\n        context = getContext(parser);\n        entity->open = XML_FALSE;\n        if (! context)\n          return XML_ERROR_NO_MEMORY;\n        if (! parser->m_externalEntityRefHandler(\n                parser->m_externalEntityRefHandlerArg, context, entity->base,\n                entity->systemId, entity->publicId))\n          return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n        poolDiscard(&parser->m_tempPool);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    }\n    case XML_TOK_START_TAG_NO_ATTS:\n      /* fall through */\n    case XML_TOK_START_TAG_WITH_ATTS: {\n      TAG *tag;\n      enum XML_Error result;\n      XML_Char *toPtr;\n      if (parser->m_freeTagList) {\n        tag = parser->m_freeTagList;\n        parser->m_freeTagList = parser->m_freeTagList->parent;\n      } else {\n        tag = MALLOC(parser, sizeof(TAG));\n        if (! tag)\n          return XML_ERROR_NO_MEMORY;\n        tag->buf.raw = MALLOC(parser, INIT_TAG_BUF_SIZE);\n        if (! tag->buf.raw) {\n          FREE(parser, tag);\n          return XML_ERROR_NO_MEMORY;\n        }\n        tag->bufEnd = tag->buf.raw + INIT_TAG_BUF_SIZE;\n      }\n      tag->bindings = NULL;\n      tag->parent = parser->m_tagStack;\n      parser->m_tagStack = tag;\n      tag->name.localPart = NULL;\n      tag->name.prefix = NULL;\n      tag->rawName = s + enc->minBytesPerChar;\n      tag->rawNameLength = XmlNameLength(enc, tag->rawName);\n      ++parser->m_tagLevel;\n      {\n        const char *rawNameEnd = tag->rawName + tag->rawNameLength;\n        const char *fromPtr = tag->rawName;\n        toPtr = tag->buf.str;\n        for (;;) {\n          int convLen;\n          const enum XML_Convert_Result convert_res\n              = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,\n                           (ICHAR *)tag->bufEnd - 1);\n          convLen = (int)(toPtr - tag->buf.str);\n          if ((fromPtr >= rawNameEnd)\n              || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {\n            tag->name.strLen = convLen;\n            break;\n          }\n          if (SIZE_MAX / 2 < (size_t)(tag->bufEnd - tag->buf.raw))\n            return XML_ERROR_NO_MEMORY;\n          const size_t bufSize = (size_t)(tag->bufEnd - tag->buf.raw) * 2;\n          {\n            char *temp = REALLOC(parser, tag->buf.raw, bufSize);\n            if (temp == NULL)\n              return XML_ERROR_NO_MEMORY;\n            tag->buf.raw = temp;\n            tag->bufEnd = temp + bufSize;\n            toPtr = (XML_Char *)temp + convLen;\n          }\n        }\n      }\n      tag->name.str = tag->buf.str;\n      *toPtr = XML_T('\\0');\n      result\n          = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);\n      if (result)\n        return result;\n      if (parser->m_startElementHandler)\n        parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,\n                                      (const XML_Char **)parser->m_atts);\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      poolClear(&parser->m_tempPool);\n      break;\n    }\n    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:\n      /* fall through */\n    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {\n      const char *rawName = s + enc->minBytesPerChar;\n      enum XML_Error result;\n      BINDING *bindings = NULL;\n      XML_Bool noElmHandlers = XML_TRUE;\n      TAG_NAME name;\n      name.str = poolStoreString(&parser->m_tempPool, enc, rawName,\n                                 rawName + XmlNameLength(enc, rawName));\n      if (! name.str)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_tempPool);\n      result = storeAtts(parser, enc, s, &name, &bindings,\n                         XML_ACCOUNT_NONE /* token spans whole start tag */);\n      if (result != XML_ERROR_NONE) {\n        freeBindings(parser, bindings);\n        return result;\n      }\n      poolFinish(&parser->m_tempPool);\n      if (parser->m_startElementHandler) {\n        parser->m_startElementHandler(parser->m_handlerArg, name.str,\n                                      (const XML_Char **)parser->m_atts);\n        noElmHandlers = XML_FALSE;\n      }\n      if (parser->m_endElementHandler) {\n        if (parser->m_startElementHandler)\n          *eventPP = *eventEndPP;\n        parser->m_endElementHandler(parser->m_handlerArg, name.str);\n        noElmHandlers = XML_FALSE;\n      }\n      if (noElmHandlers && parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      poolClear(&parser->m_tempPool);\n      freeBindings(parser, bindings);\n    }\n      if ((parser->m_tagLevel == 0)\n          && (parser->m_parsingStatus.parsing != XML_FINISHED)) {\n        if (parser->m_parsingStatus.parsing == XML_SUSPENDED\n            || (parser->m_parsingStatus.parsing == XML_PARSING\n                && parser->m_reenter))\n          parser->m_processor = epilogProcessor;\n        else\n          return epilogProcessor(parser, next, end, nextPtr);\n      }\n      break;\n    case XML_TOK_END_TAG:\n      if (parser->m_tagLevel == startTagLevel)\n        return XML_ERROR_ASYNC_ENTITY;\n      else {\n        int len;\n        const char *rawName;\n        TAG *tag = parser->m_tagStack;\n        rawName = s + enc->minBytesPerChar * 2;\n        len = XmlNameLength(enc, rawName);\n        if (len != tag->rawNameLength\n            || memcmp(tag->rawName, rawName, len) != 0) {\n          *eventPP = rawName;\n          return XML_ERROR_TAG_MISMATCH;\n        }\n        parser->m_tagStack = tag->parent;\n        tag->parent = parser->m_freeTagList;\n        parser->m_freeTagList = tag;\n        --parser->m_tagLevel;\n        if (parser->m_endElementHandler) {\n          const XML_Char *localPart;\n          const XML_Char *prefix;\n          XML_Char *uri;\n          localPart = tag->name.localPart;\n          if (parser->m_ns && localPart) {\n            /* localPart and prefix may have been overwritten in\n               tag->name.str, since this points to the binding->uri\n               buffer which gets reused; so we have to add them again\n            */\n            uri = (XML_Char *)tag->name.str + tag->name.uriLen;\n            /* don't need to check for space - already done in storeAtts() */\n            while (*localPart)\n              *uri++ = *localPart++;\n            prefix = tag->name.prefix;\n            if (parser->m_ns_triplets && prefix) {\n              *uri++ = parser->m_namespaceSeparator;\n              while (*prefix)\n                *uri++ = *prefix++;\n            }\n            *uri = XML_T('\\0');\n          }\n          parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);\n        } else if (parser->m_defaultHandler)\n          reportDefault(parser, enc, s, next);\n        while (tag->bindings) {\n          BINDING *b = tag->bindings;\n          if (parser->m_endNamespaceDeclHandler)\n            parser->m_endNamespaceDeclHandler(parser->m_handlerArg,\n                                              b->prefix->name);\n          tag->bindings = tag->bindings->nextTagBinding;\n          b->nextTagBinding = parser->m_freeBindingList;\n          parser->m_freeBindingList = b;\n          b->prefix->binding = b->prevPrefixBinding;\n        }\n        if ((parser->m_tagLevel == 0)\n            && (parser->m_parsingStatus.parsing != XML_FINISHED)) {\n          if (parser->m_parsingStatus.parsing == XML_SUSPENDED\n              || (parser->m_parsingStatus.parsing == XML_PARSING\n                  && parser->m_reenter))\n            parser->m_processor = epilogProcessor;\n          else\n            return epilogProcessor(parser, next, end, nextPtr);\n        }\n      }\n      break;\n    case XML_TOK_CHAR_REF: {\n      int n = XmlCharRefNumber(enc, s);\n      if (n < 0)\n        return XML_ERROR_BAD_CHAR_REF;\n      if (parser->m_characterDataHandler) {\n        XML_Char buf[XML_ENCODE_MAX];\n        parser->m_characterDataHandler(parser->m_handlerArg, buf,\n                                       XmlEncode(n, (ICHAR *)buf));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_XML_DECL:\n      return XML_ERROR_MISPLACED_XML_PI;\n    case XML_TOK_DATA_NEWLINE:\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    case XML_TOK_CDATA_SECT_OPEN: {\n      enum XML_Error result;\n      if (parser->m_startCdataSectionHandler)\n        parser->m_startCdataSectionHandler(parser->m_handlerArg);\n      /* BEGIN disabled code */\n      /* Suppose you doing a transformation on a document that involves\n         changing only the character data.  You set up a defaultHandler\n         and a characterDataHandler.  The defaultHandler simply copies\n         characters through.  The characterDataHandler does the\n         transformation and writes the characters out escaping them as\n         necessary.  This case will fail to work if we leave out the\n         following two lines (because & and < inside CDATA sections will\n         be incorrectly escaped).\n\n         However, now we have a start/endCdataSectionHandler, so it seems\n         easier to let the user deal with this.\n      */\n      else if ((0) && parser->m_characterDataHandler)\n        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                                       0);\n      /* END disabled code */\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      result\n          = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);\n      if (result != XML_ERROR_NONE)\n        return result;\n      else if (! next) {\n        parser->m_processor = cdataSectionProcessor;\n        return result;\n      }\n    } break;\n    case XML_TOK_TRAILING_RSQB:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      if (parser->m_characterDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n          parser->m_characterDataHandler(\n              parser->m_handlerArg, parser->m_dataBuf,\n              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n        } else\n          parser->m_characterDataHandler(\n              parser->m_handlerArg, (const XML_Char *)s,\n              (int)((const XML_Char *)end - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, end);\n      /* We are at the end of the final buffer, should we check for\n         XML_SUSPENDED, XML_FINISHED?\n      */\n      if (startTagLevel == 0) {\n        *eventPP = end;\n        return XML_ERROR_NO_ELEMENTS;\n      }\n      if (parser->m_tagLevel != startTagLevel) {\n        *eventPP = end;\n        return XML_ERROR_ASYNC_ENTITY;\n      }\n      *nextPtr = end;\n      return XML_ERROR_NONE;\n    case XML_TOK_DATA_CHARS: {\n      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;\n      if (charDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          for (;;) {\n            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n            const enum XML_Convert_Result convert_res = XmlConvert(\n                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n            *eventEndPP = s;\n            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n            if ((convert_res == XML_CONVERT_COMPLETED)\n                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n              break;\n            *eventPP = s;\n          }\n        } else\n          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,\n                          (int)((const XML_Char *)next - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_PI:\n      if (! reportProcessingInstruction(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_COMMENT:\n      if (! reportComment(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    default:\n      /* All of the tokens produced by XmlContentTok() have their own\n       * explicit cases, so this default is not strictly necessary.\n       * However it is a useful safety net, so we retain the code and\n       * simply exclude it from the coverage tests.\n       *\n       * LCOV_EXCL_START\n       */\n      if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n      /* LCOV_EXCL_STOP */\n    }\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *eventPP = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      *eventPP = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        *nextPtr = next;\n        return XML_ERROR_NONE;\n      }\n      /* Fall through */\n    default:;\n      *eventPP = s = next;\n    }\n  }\n  /* not reached */\n}\n\n/* This function does not call free() on the allocated memory, merely\n * moving it to the parser's m_freeBindingList where it can be freed or\n * reused as appropriate.\n */\nstatic void\nfreeBindings(XML_Parser parser, BINDING *bindings) {\n  while (bindings) {\n    BINDING *b = bindings;\n\n    /* m_startNamespaceDeclHandler will have been called for this\n     * binding in addBindings(), so call the end handler now.\n     */\n    if (parser->m_endNamespaceDeclHandler)\n      parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);\n\n    bindings = bindings->nextTagBinding;\n    b->nextTagBinding = parser->m_freeBindingList;\n    parser->m_freeBindingList = b;\n    b->prefix->binding = b->prevPrefixBinding;\n  }\n}\n\n/* Precondition: all arguments must be non-NULL;\n   Purpose:\n   - normalize attributes\n   - check attributes for well-formedness\n   - generate namespace aware attribute names (URI, prefix)\n   - build list of attributes for startElementHandler\n   - default attributes\n   - process namespace declarations (check and report them)\n   - generate namespace aware element name (URI, prefix)\n*/\nstatic enum XML_Error\nstoreAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,\n          TAG_NAME *tagNamePtr, BINDING **bindingsPtr,\n          enum XML_Account account) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  ELEMENT_TYPE *elementType;\n  int nDefaultAtts;\n  const XML_Char **appAtts; /* the attribute list for the application */\n  int attIndex = 0;\n  int prefixLen;\n  int i;\n  int n;\n  XML_Char *uri;\n  int nPrefixes = 0;\n  BINDING *binding;\n  const XML_Char *localPart;\n\n  /* lookup the element type name */\n  elementType\n      = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);\n  if (! elementType) {\n    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);\n    if (! name)\n      return XML_ERROR_NO_MEMORY;\n    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,\n                                         sizeof(ELEMENT_TYPE));\n    if (! elementType)\n      return XML_ERROR_NO_MEMORY;\n    if (parser->m_ns && ! setElementTypePrefix(parser, elementType))\n      return XML_ERROR_NO_MEMORY;\n  }\n  nDefaultAtts = elementType->nDefaultAtts;\n\n  /* get the attributes from the tokenizer */\n  n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);\n\n  /* Detect and prevent integer overflow */\n  if (n > INT_MAX - nDefaultAtts) {\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  if (n + nDefaultAtts > parser->m_attsSize) {\n    int oldAttsSize = parser->m_attsSize;\n    ATTRIBUTE *temp;\n#ifdef XML_ATTR_INFO\n    XML_AttrInfo *temp2;\n#endif\n\n    /* Detect and prevent integer overflow */\n    if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)\n        || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {\n      return XML_ERROR_NO_MEMORY;\n    }\n\n    parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;\n\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)parser->m_attsSize > SIZE_MAX / sizeof(ATTRIBUTE)) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    temp = REALLOC(parser, parser->m_atts,\n                   parser->m_attsSize * sizeof(ATTRIBUTE));\n    if (temp == NULL) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_atts = temp;\n#ifdef XML_ATTR_INFO\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#  if UINT_MAX >= SIZE_MAX\n    if ((unsigned)parser->m_attsSize > SIZE_MAX / sizeof(XML_AttrInfo)) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n#  endif\n\n    temp2 = REALLOC(parser, parser->m_attInfo,\n                    parser->m_attsSize * sizeof(XML_AttrInfo));\n    if (temp2 == NULL) {\n      parser->m_attsSize = oldAttsSize;\n      return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_attInfo = temp2;\n#endif\n    if (n > oldAttsSize)\n      XmlGetAttributes(enc, attStr, n, parser->m_atts);\n  }\n\n  appAtts = (const XML_Char **)parser->m_atts;\n  for (i = 0; i < n; i++) {\n    ATTRIBUTE *currAtt = &parser->m_atts[i];\n#ifdef XML_ATTR_INFO\n    XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];\n#endif\n    /* add the name and value to the attribute list */\n    ATTRIBUTE_ID *attId\n        = getAttributeId(parser, enc, currAtt->name,\n                         currAtt->name + XmlNameLength(enc, currAtt->name));\n    if (! attId)\n      return XML_ERROR_NO_MEMORY;\n#ifdef XML_ATTR_INFO\n    currAttInfo->nameStart\n        = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);\n    currAttInfo->nameEnd\n        = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);\n    currAttInfo->valueStart = parser->m_parseEndByteIndex\n                              - (parser->m_parseEndPtr - currAtt->valuePtr);\n    currAttInfo->valueEnd = parser->m_parseEndByteIndex\n                            - (parser->m_parseEndPtr - currAtt->valueEnd);\n#endif\n    /* Detect duplicate attributes by their QNames. This does not work when\n       namespace processing is turned on and different prefixes for the same\n       namespace are used. For this case we have a check further down.\n    */\n    if ((attId->name)[-1]) {\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = parser->m_atts[i].name;\n      return XML_ERROR_DUPLICATE_ATTRIBUTE;\n    }\n    (attId->name)[-1] = 1;\n    appAtts[attIndex++] = attId->name;\n    if (! parser->m_atts[i].normalized) {\n      enum XML_Error result;\n      XML_Bool isCdata = XML_TRUE;\n\n      /* figure out whether declared as other than CDATA */\n      if (attId->maybeTokenized) {\n        int j;\n        for (j = 0; j < nDefaultAtts; j++) {\n          if (attId == elementType->defaultAtts[j].id) {\n            isCdata = elementType->defaultAtts[j].isCdata;\n            break;\n          }\n        }\n      }\n\n      /* normalize the attribute value */\n      result = storeAttributeValue(\n          parser, enc, isCdata, parser->m_atts[i].valuePtr,\n          parser->m_atts[i].valueEnd, &parser->m_tempPool, account);\n      if (result)\n        return result;\n      appAtts[attIndex] = poolStart(&parser->m_tempPool);\n      poolFinish(&parser->m_tempPool);\n    } else {\n      /* the value did not need normalizing */\n      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,\n                                          parser->m_atts[i].valuePtr,\n                                          parser->m_atts[i].valueEnd);\n      if (appAtts[attIndex] == 0)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_tempPool);\n    }\n    /* handle prefixed attribute names */\n    if (attId->prefix) {\n      if (attId->xmlns) {\n        /* deal with namespace declarations here */\n        enum XML_Error result = addBinding(parser, attId->prefix, attId,\n                                           appAtts[attIndex], bindingsPtr);\n        if (result)\n          return result;\n        --attIndex;\n      } else {\n        /* deal with other prefixed names later */\n        attIndex++;\n        nPrefixes++;\n        (attId->name)[-1] = 2;\n      }\n    } else\n      attIndex++;\n  }\n\n  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */\n  parser->m_nSpecifiedAtts = attIndex;\n  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {\n    for (i = 0; i < attIndex; i += 2)\n      if (appAtts[i] == elementType->idAtt->name) {\n        parser->m_idAttIndex = i;\n        break;\n      }\n  } else\n    parser->m_idAttIndex = -1;\n\n  /* do attribute defaulting */\n  for (i = 0; i < nDefaultAtts; i++) {\n    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;\n    if (! (da->id->name)[-1] && da->value) {\n      if (da->id->prefix) {\n        if (da->id->xmlns) {\n          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,\n                                             da->value, bindingsPtr);\n          if (result)\n            return result;\n        } else {\n          (da->id->name)[-1] = 2;\n          nPrefixes++;\n          appAtts[attIndex++] = da->id->name;\n          appAtts[attIndex++] = da->value;\n        }\n      } else {\n        (da->id->name)[-1] = 1;\n        appAtts[attIndex++] = da->id->name;\n        appAtts[attIndex++] = da->value;\n      }\n    }\n  }\n  appAtts[attIndex] = 0;\n\n  /* expand prefixed attribute names, check for duplicates,\n     and clear flags that say whether attributes were specified */\n  i = 0;\n  if (nPrefixes) {\n    unsigned int j; /* hash table index */\n    unsigned long version = parser->m_nsAttsVersion;\n\n    /* Detect and prevent invalid shift */\n    if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {\n      return XML_ERROR_NO_MEMORY;\n    }\n\n    unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;\n    unsigned char oldNsAttsPower = parser->m_nsAttsPower;\n    /* size of hash table must be at least 2 * (# of prefixed attributes) */\n    if ((nPrefixes << 1)\n        >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */\n      NS_ATT *temp;\n      /* hash table size must also be a power of 2 and >= 8 */\n      while (nPrefixes >> parser->m_nsAttsPower++)\n        ;\n      if (parser->m_nsAttsPower < 3)\n        parser->m_nsAttsPower = 3;\n\n      /* Detect and prevent invalid shift */\n      if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n\n      nsAttsSize = 1u << parser->m_nsAttsPower;\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if (nsAttsSize > SIZE_MAX / sizeof(NS_ATT)) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n#endif\n\n      temp = REALLOC(parser, parser->m_nsAtts, nsAttsSize * sizeof(NS_ATT));\n      if (! temp) {\n        /* Restore actual size of memory in m_nsAtts */\n        parser->m_nsAttsPower = oldNsAttsPower;\n        return XML_ERROR_NO_MEMORY;\n      }\n      parser->m_nsAtts = temp;\n      version = 0; /* force re-initialization of m_nsAtts hash table */\n    }\n    /* using a version flag saves us from initializing m_nsAtts every time */\n    if (! version) { /* initialize version flags when version wraps around */\n      version = INIT_ATTS_VERSION;\n      for (j = nsAttsSize; j != 0;)\n        parser->m_nsAtts[--j].version = version;\n    }\n    parser->m_nsAttsVersion = --version;\n\n    /* expand prefixed names and check for duplicates */\n    for (; i < attIndex; i += 2) {\n      const XML_Char *s = appAtts[i];\n      if (s[-1] == 2) { /* prefixed */\n        ATTRIBUTE_ID *id;\n        const BINDING *b;\n        unsigned long uriHash;\n        struct siphash sip_state;\n        struct sipkey sip_key;\n\n        copy_salt_to_sipkey(parser, &sip_key);\n        sip24_init(&sip_state, &sip_key);\n\n        ((XML_Char *)s)[-1] = 0; /* clear flag */\n        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);\n        if (! id || ! id->prefix) {\n          /* This code is walking through the appAtts array, dealing\n           * with (in this case) a prefixed attribute name.  To be in\n           * the array, the attribute must have already been bound, so\n           * has to have passed through the hash table lookup once\n           * already.  That implies that an entry for it already\n           * exists, so the lookup above will return a pointer to\n           * already allocated memory.  There is no opportunaity for\n           * the allocator to fail, so the condition above cannot be\n           * fulfilled.\n           *\n           * Since it is difficult to be certain that the above\n           * analysis is complete, we retain the test and merely\n           * remove the code from coverage tests.\n           */\n          return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */\n        }\n        b = id->prefix->binding;\n        if (! b)\n          return XML_ERROR_UNBOUND_PREFIX;\n\n        for (j = 0; j < (unsigned int)b->uriLen; j++) {\n          const XML_Char c = b->uri[j];\n          if (! poolAppendChar(&parser->m_tempPool, c))\n            return XML_ERROR_NO_MEMORY;\n        }\n\n        sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));\n\n        while (*s++ != XML_T(ASCII_COLON))\n          ;\n\n        sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));\n\n        do { /* copies null terminator */\n          if (! poolAppendChar(&parser->m_tempPool, *s))\n            return XML_ERROR_NO_MEMORY;\n        } while (*s++);\n\n        uriHash = (unsigned long)sip24_final(&sip_state);\n\n        { /* Check hash table for duplicate of expanded name (uriName).\n             Derived from code in lookup(parser, HASH_TABLE *table, ...).\n          */\n          unsigned char step = 0;\n          unsigned long mask = nsAttsSize - 1;\n          j = uriHash & mask; /* index into hash table */\n          while (parser->m_nsAtts[j].version == version) {\n            /* for speed we compare stored hash values first */\n            if (uriHash == parser->m_nsAtts[j].hash) {\n              const XML_Char *s1 = poolStart(&parser->m_tempPool);\n              const XML_Char *s2 = parser->m_nsAtts[j].uriName;\n              /* s1 is null terminated, but not s2 */\n              for (; *s1 == *s2 && *s1 != 0; s1++, s2++)\n                ;\n              if (*s1 == 0)\n                return XML_ERROR_DUPLICATE_ATTRIBUTE;\n            }\n            if (! step)\n              step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);\n            j < step ? (j += nsAttsSize - step) : (j -= step);\n          }\n        }\n\n        if (parser->m_ns_triplets) { /* append namespace separator and prefix */\n          parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;\n          s = b->prefix->name;\n          do {\n            if (! poolAppendChar(&parser->m_tempPool, *s))\n              return XML_ERROR_NO_MEMORY;\n          } while (*s++);\n        }\n\n        /* store expanded name in attribute list */\n        s = poolStart(&parser->m_tempPool);\n        poolFinish(&parser->m_tempPool);\n        appAtts[i] = s;\n\n        /* fill empty slot with new version, uriName and hash value */\n        parser->m_nsAtts[j].version = version;\n        parser->m_nsAtts[j].hash = uriHash;\n        parser->m_nsAtts[j].uriName = s;\n\n        if (! --nPrefixes) {\n          i += 2;\n          break;\n        }\n      } else                     /* not prefixed */\n        ((XML_Char *)s)[-1] = 0; /* clear flag */\n    }\n  }\n  /* clear flags for the remaining attributes */\n  for (; i < attIndex; i += 2)\n    ((XML_Char *)(appAtts[i]))[-1] = 0;\n  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)\n    binding->attId->name[-1] = 0;\n\n  if (! parser->m_ns)\n    return XML_ERROR_NONE;\n\n  /* expand the element type name */\n  if (elementType->prefix) {\n    binding = elementType->prefix->binding;\n    if (! binding)\n      return XML_ERROR_UNBOUND_PREFIX;\n    localPart = tagNamePtr->str;\n    while (*localPart++ != XML_T(ASCII_COLON))\n      ;\n  } else if (dtd->defaultPrefix.binding) {\n    binding = dtd->defaultPrefix.binding;\n    localPart = tagNamePtr->str;\n  } else\n    return XML_ERROR_NONE;\n  prefixLen = 0;\n  if (parser->m_ns_triplets && binding->prefix->name) {\n    while (binding->prefix->name[prefixLen++])\n      ; /* prefixLen includes null terminator */\n  }\n  tagNamePtr->localPart = localPart;\n  tagNamePtr->uriLen = binding->uriLen;\n  tagNamePtr->prefix = binding->prefix->name;\n  tagNamePtr->prefixLen = prefixLen;\n  for (i = 0; localPart[i++];)\n    ; /* i includes null terminator */\n\n  /* Detect and prevent integer overflow */\n  if (binding->uriLen > INT_MAX - prefixLen\n      || i > INT_MAX - (binding->uriLen + prefixLen)) {\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  n = i + binding->uriLen + prefixLen;\n  if (n > binding->uriAlloc) {\n    TAG *p;\n\n    /* Detect and prevent integer overflow */\n    if (n > INT_MAX - EXPAND_SPARE) {\n      return XML_ERROR_NO_MEMORY;\n    }\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)(n + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    uri = MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));\n    if (! uri)\n      return XML_ERROR_NO_MEMORY;\n    binding->uriAlloc = n + EXPAND_SPARE;\n    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));\n    for (p = parser->m_tagStack; p; p = p->parent)\n      if (p->name.str == binding->uri)\n        p->name.str = uri;\n    FREE(parser, binding->uri);\n    binding->uri = uri;\n  }\n  /* if m_namespaceSeparator != '\\0' then uri includes it already */\n  uri = binding->uri + binding->uriLen;\n  memcpy(uri, localPart, i * sizeof(XML_Char));\n  /* we always have a namespace separator between localPart and prefix */\n  if (prefixLen) {\n    uri += i - 1;\n    *uri = parser->m_namespaceSeparator; /* replace null terminator */\n    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));\n  }\n  tagNamePtr->str = binding->uri;\n  return XML_ERROR_NONE;\n}\n\nstatic XML_Bool\nis_rfc3986_uri_char(XML_Char candidate) {\n  // For the RFC 3986 ANBF grammar see\n  // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A\n\n  switch (candidate) {\n  // From rule \"ALPHA\" (uppercase half)\n  case 'A':\n  case 'B':\n  case 'C':\n  case 'D':\n  case 'E':\n  case 'F':\n  case 'G':\n  case 'H':\n  case 'I':\n  case 'J':\n  case 'K':\n  case 'L':\n  case 'M':\n  case 'N':\n  case 'O':\n  case 'P':\n  case 'Q':\n  case 'R':\n  case 'S':\n  case 'T':\n  case 'U':\n  case 'V':\n  case 'W':\n  case 'X':\n  case 'Y':\n  case 'Z':\n\n  // From rule \"ALPHA\" (lowercase half)\n  case 'a':\n  case 'b':\n  case 'c':\n  case 'd':\n  case 'e':\n  case 'f':\n  case 'g':\n  case 'h':\n  case 'i':\n  case 'j':\n  case 'k':\n  case 'l':\n  case 'm':\n  case 'n':\n  case 'o':\n  case 'p':\n  case 'q':\n  case 'r':\n  case 's':\n  case 't':\n  case 'u':\n  case 'v':\n  case 'w':\n  case 'x':\n  case 'y':\n  case 'z':\n\n  // From rule \"DIGIT\"\n  case '0':\n  case '1':\n  case '2':\n  case '3':\n  case '4':\n  case '5':\n  case '6':\n  case '7':\n  case '8':\n  case '9':\n\n  // From rule \"pct-encoded\"\n  case '%':\n\n  // From rule \"unreserved\"\n  case '-':\n  case '.':\n  case '_':\n  case '~':\n\n  // From rule \"gen-delims\"\n  case ':':\n  case '/':\n  case '?':\n  case '#':\n  case '[':\n  case ']':\n  case '@':\n\n  // From rule \"sub-delims\"\n  case '!':\n  case '$':\n  case '&':\n  case '\\'':\n  case '(':\n  case ')':\n  case '*':\n  case '+':\n  case ',':\n  case ';':\n  case '=':\n    return XML_TRUE;\n\n  default:\n    return XML_FALSE;\n  }\n}\n\n/* addBinding() overwrites the value of prefix->binding without checking.\n   Therefore one must keep track of the old value outside of addBinding().\n*/\nstatic enum XML_Error\naddBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,\n           const XML_Char *uri, BINDING **bindingsPtr) {\n  // \"http://www.w3.org/XML/1998/namespace\"\n  static const XML_Char xmlNamespace[]\n      = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,\n         ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,\n         ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,\n         ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,\n         ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,\n         ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,\n         ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,\n         ASCII_e,      '\\0'};\n  static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;\n  // \"http://www.w3.org/2000/xmlns/\"\n  static const XML_Char xmlnsNamespace[]\n      = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,\n         ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,\n         ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,\n         ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,\n         ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\\0'};\n  static const int xmlnsLen\n      = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;\n\n  XML_Bool mustBeXML = XML_FALSE;\n  XML_Bool isXML = XML_TRUE;\n  XML_Bool isXMLNS = XML_TRUE;\n\n  BINDING *b;\n  int len;\n\n  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */\n  if (*uri == XML_T('\\0') && prefix->name)\n    return XML_ERROR_UNDECLARING_PREFIX;\n\n  if (prefix->name && prefix->name[0] == XML_T(ASCII_x)\n      && prefix->name[1] == XML_T(ASCII_m)\n      && prefix->name[2] == XML_T(ASCII_l)) {\n    /* Not allowed to bind xmlns */\n    if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)\n        && prefix->name[5] == XML_T('\\0'))\n      return XML_ERROR_RESERVED_PREFIX_XMLNS;\n\n    if (prefix->name[3] == XML_T('\\0'))\n      mustBeXML = XML_TRUE;\n  }\n\n  for (len = 0; uri[len]; len++) {\n    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))\n      isXML = XML_FALSE;\n\n    if (! mustBeXML && isXMLNS\n        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))\n      isXMLNS = XML_FALSE;\n\n    // NOTE: While Expat does not validate namespace URIs against RFC 3986\n    //       today (and is not REQUIRED to do so with regard to the XML 1.0\n    //       namespaces specification) we have to at least make sure, that\n    //       the application on top of Expat (that is likely splitting expanded\n    //       element names (\"qualified names\") of form\n    //       \"[uri sep] local [sep prefix] '\\0'\" back into 1, 2 or 3 pieces\n    //       in its element handler code) cannot be confused by an attacker\n    //       putting additional namespace separator characters into namespace\n    //       declarations.  That would be ambiguous and not to be expected.\n    //\n    //       While the HTML API docs of function XML_ParserCreateNS have been\n    //       advising against use of a namespace separator character that can\n    //       appear in a URI for >20 years now, some widespread applications\n    //       are using URI characters (':' (colon) in particular) for a\n    //       namespace separator, in practice.  To keep these applications\n    //       functional, we only reject namespaces URIs containing the\n    //       application-chosen namespace separator if the chosen separator\n    //       is a non-URI character with regard to RFC 3986.\n    if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)\n        && ! is_rfc3986_uri_char(uri[len])) {\n      return XML_ERROR_SYNTAX;\n    }\n  }\n  isXML = isXML && len == xmlLen;\n  isXMLNS = isXMLNS && len == xmlnsLen;\n\n  if (mustBeXML != isXML)\n    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML\n                     : XML_ERROR_RESERVED_NAMESPACE_URI;\n\n  if (isXMLNS)\n    return XML_ERROR_RESERVED_NAMESPACE_URI;\n\n  if (parser->m_namespaceSeparator)\n    len++;\n  if (parser->m_freeBindingList) {\n    b = parser->m_freeBindingList;\n    if (len > b->uriAlloc) {\n      /* Detect and prevent integer overflow */\n      if (len > INT_MAX - EXPAND_SPARE) {\n        return XML_ERROR_NO_MEMORY;\n      }\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((unsigned)(len + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n        return XML_ERROR_NO_MEMORY;\n      }\n#endif\n\n      XML_Char *temp\n          = REALLOC(parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));\n      if (temp == NULL)\n        return XML_ERROR_NO_MEMORY;\n      b->uri = temp;\n      b->uriAlloc = len + EXPAND_SPARE;\n    }\n    parser->m_freeBindingList = b->nextTagBinding;\n  } else {\n    b = MALLOC(parser, sizeof(BINDING));\n    if (! b)\n      return XML_ERROR_NO_MEMORY;\n\n    /* Detect and prevent integer overflow */\n    if (len > INT_MAX - EXPAND_SPARE) {\n      return XML_ERROR_NO_MEMORY;\n    }\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if ((unsigned)(len + EXPAND_SPARE) > SIZE_MAX / sizeof(XML_Char)) {\n      return XML_ERROR_NO_MEMORY;\n    }\n#endif\n\n    b->uri = MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));\n    if (! b->uri) {\n      FREE(parser, b);\n      return XML_ERROR_NO_MEMORY;\n    }\n    b->uriAlloc = len + EXPAND_SPARE;\n  }\n  b->uriLen = len;\n  memcpy(b->uri, uri, len * sizeof(XML_Char));\n  if (parser->m_namespaceSeparator)\n    b->uri[len - 1] = parser->m_namespaceSeparator;\n  b->prefix = prefix;\n  b->attId = attId;\n  b->prevPrefixBinding = prefix->binding;\n  /* NULL binding when default namespace undeclared */\n  if (*uri == XML_T('\\0') && prefix == &parser->m_dtd->defaultPrefix)\n    prefix->binding = NULL;\n  else\n    prefix->binding = b;\n  b->nextTagBinding = *bindingsPtr;\n  *bindingsPtr = b;\n  /* if attId == NULL then we are not starting a namespace scope */\n  if (attId && parser->m_startNamespaceDeclHandler)\n    parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,\n                                        prefix->binding ? uri : 0);\n  return XML_ERROR_NONE;\n}\n\n/* The idea here is to avoid using stack for each CDATA section when\n   the whole file is parsed with one call.\n*/\nstatic enum XML_Error PTRCALL\ncdataSectionProcessor(XML_Parser parser, const char *start, const char *end,\n                      const char **endPtr) {\n  enum XML_Error result = doCdataSection(\n      parser, parser->m_encoding, &start, end, endPtr,\n      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);\n  if (result != XML_ERROR_NONE)\n    return result;\n  if (start) {\n    if (parser->m_parentParser) { /* we are parsing an external entity */\n      parser->m_processor = externalEntityContentProcessor;\n      return externalEntityContentProcessor(parser, start, end, endPtr);\n    } else {\n      parser->m_processor = contentProcessor;\n      return contentProcessor(parser, start, end, endPtr);\n    }\n  }\n  return result;\n}\n\n/* startPtr gets set to non-null if the section is closed, and to null if\n   the section is not yet closed.\n*/\nstatic enum XML_Error\ndoCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,\n               const char *end, const char **nextPtr, XML_Bool haveMore,\n               enum XML_Account account) {\n  const char *s = *startPtr;\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    *eventPP = s;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n  *eventPP = s;\n  *startPtr = NULL;\n\n  for (;;) {\n    const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */\n    int tok = XmlCdataSectionTok(enc, s, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#else\n    UNUSED_P(account);\n#endif\n    *eventEndPP = next;\n    switch (tok) {\n    case XML_TOK_CDATA_SECT_CLOSE:\n      if (parser->m_endCdataSectionHandler)\n        parser->m_endCdataSectionHandler(parser->m_handlerArg);\n      /* BEGIN disabled code */\n      /* see comment under XML_TOK_CDATA_SECT_OPEN */\n      else if ((0) && parser->m_characterDataHandler)\n        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                                       0);\n      /* END disabled code */\n      else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      *startPtr = next;\n      *nextPtr = next;\n      if (parser->m_parsingStatus.parsing == XML_FINISHED)\n        return XML_ERROR_ABORTED;\n      else\n        return XML_ERROR_NONE;\n    case XML_TOK_DATA_NEWLINE:\n      if (parser->m_characterDataHandler) {\n        XML_Char c = 0xA;\n        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      break;\n    case XML_TOK_DATA_CHARS: {\n      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;\n      if (charDataHandler) {\n        if (MUST_CONVERT(enc, s)) {\n          for (;;) {\n            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n            const enum XML_Convert_Result convert_res = XmlConvert(\n                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n            *eventEndPP = next;\n            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,\n                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n            if ((convert_res == XML_CONVERT_COMPLETED)\n                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n              break;\n            *eventPP = s;\n          }\n        } else\n          charDataHandler(parser->m_handlerArg, (const XML_Char *)s,\n                          (int)((const XML_Char *)next - (const XML_Char *)s));\n      } else if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n    } break;\n    case XML_TOK_INVALID:\n      *eventPP = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_PARTIAL:\n    case XML_TOK_NONE:\n      if (haveMore) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_CDATA_SECTION;\n    default:\n      /* Every token returned by XmlCdataSectionTok() has its own\n       * explicit case, so this default case will never be executed.\n       * We retain it as a safety net and exclude it from the coverage\n       * statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      *eventPP = next;\n      return XML_ERROR_UNEXPECTED_STATE;\n      /* LCOV_EXCL_STOP */\n    }\n\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *eventPP = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      *eventPP = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n      /* Fall through */\n    default:;\n      *eventPP = s = next;\n    }\n  }\n  /* not reached */\n}\n\n#ifdef XML_DTD\n\n/* The idea here is to avoid using stack for each IGNORE section when\n   the whole file is parsed with one call.\n*/\nstatic enum XML_Error PTRCALL\nignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,\n                       const char **endPtr) {\n  enum XML_Error result\n      = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,\n                        (XML_Bool)! parser->m_parsingStatus.finalBuffer);\n  if (result != XML_ERROR_NONE)\n    return result;\n  if (start) {\n    parser->m_processor = prologProcessor;\n    return prologProcessor(parser, start, end, endPtr);\n  }\n  return result;\n}\n\n/* startPtr gets set to non-null is the section is closed, and to null\n   if the section is not yet closed.\n*/\nstatic enum XML_Error\ndoIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,\n                const char *end, const char **nextPtr, XML_Bool haveMore) {\n  const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */\n  int tok;\n  const char *s = *startPtr;\n  const char **eventPP;\n  const char **eventEndPP;\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    *eventPP = s;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    /* It's not entirely clear, but it seems the following two lines\n     * of code cannot be executed.  The only occasions on which 'enc'\n     * is not 'encoding' are when this function is called\n     * from the internal entity processing, and IGNORE sections are an\n     * error in internal entities.\n     *\n     * Since it really isn't clear that this is true, we keep the code\n     * and just remove it from our coverage tests.\n     *\n     * LCOV_EXCL_START\n     */\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n    /* LCOV_EXCL_STOP */\n  }\n  *eventPP = s;\n  *startPtr = NULL;\n  tok = XmlIgnoreSectionTok(enc, s, end, &next);\n#  if XML_GE == 1\n  if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                XML_ACCOUNT_DIRECT)) {\n    accountingOnAbort(parser);\n    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n  }\n#  endif\n  *eventEndPP = next;\n  switch (tok) {\n  case XML_TOK_IGNORE_SECT:\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, s, next);\n    *startPtr = next;\n    *nextPtr = next;\n    if (parser->m_parsingStatus.parsing == XML_FINISHED)\n      return XML_ERROR_ABORTED;\n    else\n      return XML_ERROR_NONE;\n  case XML_TOK_INVALID:\n    *eventPP = next;\n    return XML_ERROR_INVALID_TOKEN;\n  case XML_TOK_PARTIAL_CHAR:\n    if (haveMore) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_PARTIAL_CHAR;\n  case XML_TOK_PARTIAL:\n  case XML_TOK_NONE:\n    if (haveMore) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */\n  default:\n    /* All of the tokens that XmlIgnoreSectionTok() returns have\n     * explicit cases to handle them, so this default case is never\n     * executed.  We keep it as a safety net anyway, and remove it\n     * from our test coverage statistics.\n     *\n     * LCOV_EXCL_START\n     */\n    *eventPP = next;\n    return XML_ERROR_UNEXPECTED_STATE;\n    /* LCOV_EXCL_STOP */\n  }\n  /* not reached */\n}\n\n#endif /* XML_DTD */\n\nstatic enum XML_Error\ninitializeEncoding(XML_Parser parser) {\n  const char *s;\n#ifdef XML_UNICODE\n  char encodingBuf[128];\n  /* See comments about `protocolEncodingName` in parserInit() */\n  if (! parser->m_protocolEncodingName)\n    s = NULL;\n  else {\n    int i;\n    for (i = 0; parser->m_protocolEncodingName[i]; i++) {\n      if (i == sizeof(encodingBuf) - 1\n          || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {\n        encodingBuf[0] = '\\0';\n        break;\n      }\n      encodingBuf[i] = (char)parser->m_protocolEncodingName[i];\n    }\n    encodingBuf[i] = '\\0';\n    s = encodingBuf;\n  }\n#else\n  s = parser->m_protocolEncodingName;\n#endif\n  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(\n          &parser->m_initEncoding, &parser->m_encoding, s))\n    return XML_ERROR_NONE;\n  return handleUnknownEncoding(parser, parser->m_protocolEncodingName);\n}\n\nstatic enum XML_Error\nprocessXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,\n               const char *next) {\n  const char *encodingName = NULL;\n  const XML_Char *storedEncName = NULL;\n  const ENCODING *newEncoding = NULL;\n  const char *version = NULL;\n  const char *versionend = NULL;\n  const XML_Char *storedversion = NULL;\n  int standalone = -1;\n\n#if XML_GE == 1\n  if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,\n                                XML_ACCOUNT_DIRECT)) {\n    accountingOnAbort(parser);\n    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n  }\n#endif\n\n  if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(\n          isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,\n          &version, &versionend, &encodingName, &newEncoding, &standalone)) {\n    if (isGeneralTextEntity)\n      return XML_ERROR_TEXT_DECL;\n    else\n      return XML_ERROR_XML_DECL;\n  }\n  if (! isGeneralTextEntity && standalone == 1) {\n    parser->m_dtd->standalone = XML_TRUE;\n#ifdef XML_DTD\n    if (parser->m_paramEntityParsing\n        == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)\n      parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;\n#endif /* XML_DTD */\n  }\n  if (parser->m_xmlDeclHandler) {\n    if (encodingName != NULL) {\n      storedEncName = poolStoreString(\n          &parser->m_temp2Pool, parser->m_encoding, encodingName,\n          encodingName + XmlNameLength(parser->m_encoding, encodingName));\n      if (! storedEncName)\n        return XML_ERROR_NO_MEMORY;\n      poolFinish(&parser->m_temp2Pool);\n    }\n    if (version) {\n      storedversion\n          = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,\n                            versionend - parser->m_encoding->minBytesPerChar);\n      if (! storedversion)\n        return XML_ERROR_NO_MEMORY;\n    }\n    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,\n                             standalone);\n  } else if (parser->m_defaultHandler)\n    reportDefault(parser, parser->m_encoding, s, next);\n  if (parser->m_protocolEncodingName == NULL) {\n    if (newEncoding) {\n      /* Check that the specified encoding does not conflict with what\n       * the parser has already deduced.  Do we have the same number\n       * of bytes in the smallest representation of a character?  If\n       * this is UTF-16, is it the same endianness?\n       */\n      if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar\n          || (newEncoding->minBytesPerChar == 2\n              && newEncoding != parser->m_encoding)) {\n        parser->m_eventPtr = encodingName;\n        return XML_ERROR_INCORRECT_ENCODING;\n      }\n      parser->m_encoding = newEncoding;\n    } else if (encodingName) {\n      enum XML_Error result;\n      if (! storedEncName) {\n        storedEncName = poolStoreString(\n            &parser->m_temp2Pool, parser->m_encoding, encodingName,\n            encodingName + XmlNameLength(parser->m_encoding, encodingName));\n        if (! storedEncName)\n          return XML_ERROR_NO_MEMORY;\n      }\n      result = handleUnknownEncoding(parser, storedEncName);\n      poolClear(&parser->m_temp2Pool);\n      if (result == XML_ERROR_UNKNOWN_ENCODING)\n        parser->m_eventPtr = encodingName;\n      return result;\n    }\n  }\n\n  if (storedEncName || storedversion)\n    poolClear(&parser->m_temp2Pool);\n\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error\nhandleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {\n  if (parser->m_unknownEncodingHandler) {\n    XML_Encoding info;\n    int i;\n    for (i = 0; i < 256; i++)\n      info.map[i] = -1;\n    info.convert = NULL;\n    info.data = NULL;\n    info.release = NULL;\n    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,\n                                         encodingName, &info)) {\n      ENCODING *enc;\n      parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());\n      if (! parser->m_unknownEncodingMem) {\n        if (info.release)\n          info.release(info.data);\n        return XML_ERROR_NO_MEMORY;\n      }\n      enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(\n          parser->m_unknownEncodingMem, info.map, info.convert, info.data);\n      if (enc) {\n        parser->m_unknownEncodingData = info.data;\n        parser->m_unknownEncodingRelease = info.release;\n        parser->m_encoding = enc;\n        return XML_ERROR_NONE;\n      }\n    }\n    if (info.release != NULL)\n      info.release(info.data);\n  }\n  return XML_ERROR_UNKNOWN_ENCODING;\n}\n\nstatic enum XML_Error PTRCALL\nprologInitProcessor(XML_Parser parser, const char *s, const char *end,\n                    const char **nextPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n  parser->m_processor = prologProcessor;\n  return prologProcessor(parser, s, end, nextPtr);\n}\n\n#ifdef XML_DTD\n\nstatic enum XML_Error PTRCALL\nexternalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,\n                            const char **nextPtr) {\n  enum XML_Error result = initializeEncoding(parser);\n  if (result != XML_ERROR_NONE)\n    return result;\n\n  /* we know now that XML_Parse(Buffer) has been called,\n     so we consider the external parameter entity read */\n  parser->m_dtd->paramEntityRead = XML_TRUE;\n\n  if (parser->m_prologState.inEntityValue) {\n    parser->m_processor = entityValueInitProcessor;\n    return entityValueInitProcessor(parser, s, end, nextPtr);\n  } else {\n    parser->m_processor = externalParEntProcessor;\n    return externalParEntProcessor(parser, s, end, nextPtr);\n  }\n}\n\nstatic enum XML_Error PTRCALL\nentityValueInitProcessor(XML_Parser parser, const char *s, const char *end,\n                         const char **nextPtr) {\n  int tok;\n  const char *start = s;\n  const char *next = start;\n  parser->m_eventPtr = start;\n\n  for (;;) {\n    tok = XmlPrologTok(parser->m_encoding, start, end, &next);\n    /* Note: Except for XML_TOK_BOM below, these bytes are accounted later in:\n             - storeEntityValue\n             - processXmlDecl\n    */\n    parser->m_eventEndPtr = next;\n    if (tok <= 0) {\n      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case XML_TOK_NONE: /* start == end */\n      default:\n        break;\n      }\n      /* found end of entity value - can store it now */\n      return storeEntityValue(parser, parser->m_encoding, s, end,\n                              XML_ACCOUNT_DIRECT, NULL);\n    } else if (tok == XML_TOK_XML_DECL) {\n      enum XML_Error result;\n      result = processXmlDecl(parser, 0, start, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For\n       * that to happen, a parameter entity parsing handler must have attempted\n       * to suspend the parser, which fails and raises an error.  The parser can\n       * be aborted, but can't be suspended.\n       */\n      if (parser->m_parsingStatus.parsing == XML_FINISHED)\n        return XML_ERROR_ABORTED;\n      *nextPtr = next;\n      /* stop scanning for text declaration - we found one */\n      parser->m_processor = entityValueProcessor;\n      return entityValueProcessor(parser, next, end, nextPtr);\n    }\n    /* XmlPrologTok has now set the encoding based on the BOM it found, and we\n       must move s and nextPtr forward to consume the BOM.\n\n       If we didn't, and got XML_TOK_NONE from the next XmlPrologTok call, we\n       would leave the BOM in the buffer and return. On the next call to this\n       function, our XmlPrologTok call would return XML_TOK_INVALID, since it\n       is not valid to have multiple BOMs.\n    */\n    else if (tok == XML_TOK_BOM) {\n#  if XML_GE == 1\n      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                    XML_ACCOUNT_DIRECT)) {\n        accountingOnAbort(parser);\n        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      }\n#  endif\n\n      *nextPtr = next;\n      s = next;\n    }\n    /* If we get this token, we have the start of what might be a\n       normal tag, but not a declaration (i.e. it doesn't begin with\n       \"<!\" or \"<?\").  In a DTD context, that isn't legal.\n    */\n    else if (tok == XML_TOK_INSTANCE_START) {\n      *nextPtr = next;\n      return XML_ERROR_SYNTAX;\n    }\n    start = next;\n    parser->m_eventPtr = start;\n  }\n}\n\nstatic enum XML_Error PTRCALL\nexternalParEntProcessor(XML_Parser parser, const char *s, const char *end,\n                        const char **nextPtr) {\n  const char *next = s;\n  int tok;\n\n  tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  if (tok <= 0) {\n    if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    }\n    switch (tok) {\n    case XML_TOK_INVALID:\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      return XML_ERROR_PARTIAL_CHAR;\n    case XML_TOK_NONE: /* start == end */\n    default:\n      break;\n    }\n  }\n  /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.\n     However, when parsing an external subset, doProlog will not accept a BOM\n     as valid, and report a syntax error, so we have to skip the BOM, and\n     account for the BOM bytes.\n  */\n  else if (tok == XML_TOK_BOM) {\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n\n    s = next;\n    tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  }\n\n  parser->m_processor = prologProcessor;\n  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,\n                  XML_ACCOUNT_DIRECT);\n}\n\nstatic enum XML_Error PTRCALL\nentityValueProcessor(XML_Parser parser, const char *s, const char *end,\n                     const char **nextPtr) {\n  const char *start = s;\n  const char *next = s;\n  const ENCODING *enc = parser->m_encoding;\n  int tok;\n\n  for (;;) {\n    tok = XmlPrologTok(enc, start, end, &next);\n    /* Note: These bytes are accounted later in:\n             - storeEntityValue\n    */\n    if (tok <= 0) {\n      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case XML_TOK_NONE: /* start == end */\n      default:\n        break;\n      }\n      /* found end of entity value - can store it now */\n      return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT, NULL);\n    }\n    /* If we get this token, we have the start of what might be a\n       normal tag, but not a declaration (i.e. it doesn't begin with\n       \"<!\" or \"<?\").  In a DTD context, that isn't legal.\n    */\n    else if (tok == XML_TOK_INSTANCE_START) {\n      *nextPtr = next;\n      return XML_ERROR_SYNTAX;\n    }\n\n    start = next;\n  }\n}\n\n#endif /* XML_DTD */\n\nstatic enum XML_Error PTRCALL\nprologProcessor(XML_Parser parser, const char *s, const char *end,\n                const char **nextPtr) {\n  const char *next = s;\n  int tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,\n                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,\n                  XML_ACCOUNT_DIRECT);\n}\n\nstatic enum XML_Error\ndoProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,\n         int tok, const char *next, const char **nextPtr, XML_Bool haveMore,\n         XML_Bool allowClosingDoctype, enum XML_Account account) {\n#ifdef XML_DTD\n  static const XML_Char externalSubsetName[] = {ASCII_HASH, '\\0'};\n#endif /* XML_DTD */\n  static const XML_Char atypeCDATA[]\n      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\\0'};\n  static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\\0'};\n  static const XML_Char atypeIDREF[]\n      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\\0'};\n  static const XML_Char atypeIDREFS[]\n      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\\0'};\n  static const XML_Char atypeENTITY[]\n      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\\0'};\n  static const XML_Char atypeENTITIES[]\n      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,\n         ASCII_I, ASCII_E, ASCII_S, '\\0'};\n  static const XML_Char atypeNMTOKEN[]\n      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\\0'};\n  static const XML_Char atypeNMTOKENS[]\n      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,\n         ASCII_E, ASCII_N, ASCII_S, '\\0'};\n  static const XML_Char notationPrefix[]\n      = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,\n         ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\\0'};\n  static const XML_Char enumValueSep[] = {ASCII_PIPE, '\\0'};\n  static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\\0'};\n\n#ifndef XML_DTD\n  UNUSED_P(account);\n#endif\n\n  /* save one level of indirection */\n  DTD *const dtd = parser->m_dtd;\n\n  const char **eventPP;\n  const char **eventEndPP;\n  enum XML_Content_Quant quant;\n\n  if (enc == parser->m_encoding) {\n    eventPP = &parser->m_eventPtr;\n    eventEndPP = &parser->m_eventEndPtr;\n  } else {\n    eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n  }\n\n  for (;;) {\n    int role;\n    XML_Bool handleDefault = XML_TRUE;\n    *eventPP = s;\n    *eventEndPP = next;\n    if (tok <= 0) {\n      if (haveMore && tok != XML_TOK_INVALID) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      switch (tok) {\n      case XML_TOK_INVALID:\n        *eventPP = next;\n        return XML_ERROR_INVALID_TOKEN;\n      case XML_TOK_PARTIAL:\n        return XML_ERROR_UNCLOSED_TOKEN;\n      case XML_TOK_PARTIAL_CHAR:\n        return XML_ERROR_PARTIAL_CHAR;\n      case -XML_TOK_PROLOG_S:\n        tok = -tok;\n        break;\n      case XML_TOK_NONE:\n#ifdef XML_DTD\n        /* for internal PE NOT referenced between declarations */\n        if (enc != parser->m_encoding\n            && ! parser->m_openInternalEntities->betweenDecl) {\n          *nextPtr = s;\n          return XML_ERROR_NONE;\n        }\n        /* WFC: PE Between Declarations - must check that PE contains\n           complete markup, not only for external PEs, but also for\n           internal PEs if the reference occurs between declarations.\n        */\n        if (parser->m_isParamEntity || enc != parser->m_encoding) {\n          if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)\n              == XML_ROLE_ERROR)\n            return XML_ERROR_INCOMPLETE_PE;\n          *nextPtr = s;\n          return XML_ERROR_NONE;\n        }\n#endif /* XML_DTD */\n        return XML_ERROR_NO_ELEMENTS;\n      default:\n        tok = -tok;\n        next = end;\n        break;\n      }\n    }\n    role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);\n#if XML_GE == 1\n    switch (role) {\n    case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor\n    case XML_ROLE_XML_DECL:       // bytes accounted in processXmlDecl\n#  ifdef XML_DTD\n    case XML_ROLE_TEXT_DECL: // bytes accounted in processXmlDecl\n#  endif\n      break;\n    default:\n      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {\n        accountingOnAbort(parser);\n        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      }\n    }\n#endif\n    switch (role) {\n    case XML_ROLE_XML_DECL: {\n      enum XML_Error result = processXmlDecl(parser, 0, s, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      enc = parser->m_encoding;\n      handleDefault = XML_FALSE;\n    } break;\n    case XML_ROLE_DOCTYPE_NAME:\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_doctypeName\n            = poolStoreString(&parser->m_tempPool, enc, s, next);\n        if (! parser->m_doctypeName)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        parser->m_doctypePubid = NULL;\n        handleDefault = XML_FALSE;\n      }\n      parser->m_doctypeSysid = NULL; /* always initialize to NULL */\n      break;\n    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_startDoctypeDeclHandler(\n            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,\n            parser->m_doctypePubid, 1);\n        parser->m_doctypeName = NULL;\n        poolClear(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n#ifdef XML_DTD\n    case XML_ROLE_TEXT_DECL: {\n      enum XML_Error result = processXmlDecl(parser, 1, s, next);\n      if (result != XML_ERROR_NONE)\n        return result;\n      enc = parser->m_encoding;\n      handleDefault = XML_FALSE;\n    } break;\n#endif /* XML_DTD */\n    case XML_ROLE_DOCTYPE_PUBLIC_ID:\n#ifdef XML_DTD\n      parser->m_useForeignDTD = XML_FALSE;\n      parser->m_declEntity = (ENTITY *)lookup(\n          parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));\n      if (! parser->m_declEntity)\n        return XML_ERROR_NO_MEMORY;\n#endif /* XML_DTD */\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (parser->m_startDoctypeDeclHandler) {\n        XML_Char *pubId;\n        if (! XmlIsPublicId(enc, s, next, eventPP))\n          return XML_ERROR_PUBLICID;\n        pubId = poolStoreString(&parser->m_tempPool, enc,\n                                s + enc->minBytesPerChar,\n                                next - enc->minBytesPerChar);\n        if (! pubId)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(pubId);\n        poolFinish(&parser->m_tempPool);\n        parser->m_doctypePubid = pubId;\n        handleDefault = XML_FALSE;\n        goto alreadyChecked;\n      }\n      /* fall through */\n    case XML_ROLE_ENTITY_PUBLIC_ID:\n      if (! XmlIsPublicId(enc, s, next, eventPP))\n        return XML_ERROR_PUBLICID;\n    alreadyChecked:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        XML_Char *tem\n            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                              next - enc->minBytesPerChar);\n        if (! tem)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(tem);\n        parser->m_declEntity->publicId = tem;\n        poolFinish(&dtd->pool);\n        /* Don't suppress the default handler if we fell through from\n         * the XML_ROLE_DOCTYPE_PUBLIC_ID case.\n         */\n        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_DOCTYPE_CLOSE:\n      if (allowClosingDoctype != XML_TRUE) {\n        /* Must not close doctype from within expanded parameter entities */\n        return XML_ERROR_INVALID_TOKEN;\n      }\n\n      if (parser->m_doctypeName) {\n        parser->m_startDoctypeDeclHandler(\n            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,\n            parser->m_doctypePubid, 0);\n        poolClear(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      /* parser->m_doctypeSysid will be non-NULL in the case of a previous\n         XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler\n         was not set, indicating an external subset\n      */\n#ifdef XML_DTD\n      if (parser->m_doctypeSysid || parser->m_useForeignDTD) {\n        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\n        dtd->hasParamEntityRefs = XML_TRUE;\n        if (parser->m_paramEntityParsing\n            && parser->m_externalEntityRefHandler) {\n          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                            externalSubsetName, sizeof(ENTITY));\n          if (! entity) {\n            /* The external subset name \"#\" will have already been\n             * inserted into the hash table at the start of the\n             * external entity parsing, so no allocation will happen\n             * and lookup() cannot fail.\n             */\n            return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */\n          }\n          if (parser->m_useForeignDTD)\n            entity->base = parser->m_curBase;\n          dtd->paramEntityRead = XML_FALSE;\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId))\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          if (dtd->paramEntityRead) {\n            if (! dtd->standalone && parser->m_notStandaloneHandler\n                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n              return XML_ERROR_NOT_STANDALONE;\n          }\n          /* if we didn't read the foreign DTD then this means that there\n             is no external subset and we must reset dtd->hasParamEntityRefs\n          */\n          else if (! parser->m_doctypeSysid)\n            dtd->hasParamEntityRefs = hadParamEntityRefs;\n          /* end of DTD - no need to update dtd->keepProcessing */\n        }\n        parser->m_useForeignDTD = XML_FALSE;\n      }\n#endif /* XML_DTD */\n      if (parser->m_endDoctypeDeclHandler) {\n        parser->m_endDoctypeDeclHandler(parser->m_handlerArg);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_INSTANCE_START:\n#ifdef XML_DTD\n      /* if there is no DOCTYPE declaration then now is the\n         last chance to read the foreign DTD\n      */\n      if (parser->m_useForeignDTD) {\n        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;\n        dtd->hasParamEntityRefs = XML_TRUE;\n        if (parser->m_paramEntityParsing\n            && parser->m_externalEntityRefHandler) {\n          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                            externalSubsetName, sizeof(ENTITY));\n          if (! entity)\n            return XML_ERROR_NO_MEMORY;\n          entity->base = parser->m_curBase;\n          dtd->paramEntityRead = XML_FALSE;\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId))\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          if (dtd->paramEntityRead) {\n            if (! dtd->standalone && parser->m_notStandaloneHandler\n                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n              return XML_ERROR_NOT_STANDALONE;\n          }\n          /* if we didn't read the foreign DTD then this means that there\n             is no external subset and we must reset dtd->hasParamEntityRefs\n          */\n          else\n            dtd->hasParamEntityRefs = hadParamEntityRefs;\n          /* end of DTD - no need to update dtd->keepProcessing */\n        }\n      }\n#endif /* XML_DTD */\n      parser->m_processor = contentProcessor;\n      return contentProcessor(parser, s, end, nextPtr);\n    case XML_ROLE_ATTLIST_ELEMENT_NAME:\n      parser->m_declElementType = getElementType(parser, enc, s, next);\n      if (! parser->m_declElementType)\n        return XML_ERROR_NO_MEMORY;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_NAME:\n      parser->m_declAttributeId = getAttributeId(parser, enc, s, next);\n      if (! parser->m_declAttributeId)\n        return XML_ERROR_NO_MEMORY;\n      parser->m_declAttributeIsCdata = XML_FALSE;\n      parser->m_declAttributeType = NULL;\n      parser->m_declAttributeIsId = XML_FALSE;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:\n      parser->m_declAttributeIsCdata = XML_TRUE;\n      parser->m_declAttributeType = atypeCDATA;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ID:\n      parser->m_declAttributeIsId = XML_TRUE;\n      parser->m_declAttributeType = atypeID;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:\n      parser->m_declAttributeType = atypeIDREF;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:\n      parser->m_declAttributeType = atypeIDREFS;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:\n      parser->m_declAttributeType = atypeENTITY;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:\n      parser->m_declAttributeType = atypeENTITIES;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:\n      parser->m_declAttributeType = atypeNMTOKEN;\n      goto checkAttListDeclHandler;\n    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:\n      parser->m_declAttributeType = atypeNMTOKENS;\n    checkAttListDeclHandler:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:\n    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler) {\n        const XML_Char *prefix;\n        if (parser->m_declAttributeType) {\n          prefix = enumValueSep;\n        } else {\n          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix\n                                                              : enumValueStart);\n        }\n        if (! poolAppendString(&parser->m_tempPool, prefix))\n          return XML_ERROR_NO_MEMORY;\n        if (! poolAppend(&parser->m_tempPool, enc, s, next))\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declAttributeType = parser->m_tempPool.start;\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:\n    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:\n      if (dtd->keepProcessing) {\n        if (! defineAttribute(parser->m_declElementType,\n                              parser->m_declAttributeId,\n                              parser->m_declAttributeIsCdata,\n                              parser->m_declAttributeIsId, 0, parser))\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {\n          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)\n              || (*parser->m_declAttributeType == XML_T(ASCII_N)\n                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {\n            /* Enumerated or Notation type */\n            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))\n                || ! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n              return XML_ERROR_NO_MEMORY;\n            parser->m_declAttributeType = parser->m_tempPool.start;\n            poolFinish(&parser->m_tempPool);\n          }\n          *eventEndPP = s;\n          parser->m_attlistDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name,\n              parser->m_declAttributeId->name, parser->m_declAttributeType, 0,\n              role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);\n          handleDefault = XML_FALSE;\n        }\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:\n    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:\n      if (dtd->keepProcessing) {\n        const XML_Char *attVal;\n        enum XML_Error result = storeAttributeValue(\n            parser, enc, parser->m_declAttributeIsCdata,\n            s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,\n            XML_ACCOUNT_NONE);\n        if (result)\n          return result;\n        attVal = poolStart(&dtd->pool);\n        poolFinish(&dtd->pool);\n        /* ID attributes aren't allowed to have a default */\n        if (! defineAttribute(\n                parser->m_declElementType, parser->m_declAttributeId,\n                parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {\n          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)\n              || (*parser->m_declAttributeType == XML_T(ASCII_N)\n                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {\n            /* Enumerated or Notation type */\n            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))\n                || ! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n              return XML_ERROR_NO_MEMORY;\n            parser->m_declAttributeType = parser->m_tempPool.start;\n            poolFinish(&parser->m_tempPool);\n          }\n          *eventEndPP = s;\n          parser->m_attlistDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name,\n              parser->m_declAttributeId->name, parser->m_declAttributeType,\n              attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);\n          poolClear(&parser->m_tempPool);\n          handleDefault = XML_FALSE;\n        }\n      }\n      break;\n    case XML_ROLE_ENTITY_VALUE:\n      if (dtd->keepProcessing) {\n#if XML_GE == 1\n        // This will store the given replacement text in\n        // parser->m_declEntity->textPtr.\n        enum XML_Error result = callStoreEntityValue(\n            parser, enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar,\n            XML_ACCOUNT_NONE);\n        if (parser->m_declEntity) {\n          parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);\n          parser->m_declEntity->textLen\n              = (int)(poolLength(&dtd->entityValuePool));\n          poolFinish(&dtd->entityValuePool);\n          if (parser->m_entityDeclHandler) {\n            *eventEndPP = s;\n            parser->m_entityDeclHandler(\n                parser->m_handlerArg, parser->m_declEntity->name,\n                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,\n                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);\n            handleDefault = XML_FALSE;\n          }\n        } else\n          poolDiscard(&dtd->entityValuePool);\n        if (result != XML_ERROR_NONE)\n          return result;\n#else\n        // This will store \"&amp;entity123;\" in parser->m_declEntity->textPtr\n        // to end up as \"&entity123;\" in the handler.\n        if (parser->m_declEntity != NULL) {\n          const enum XML_Error result\n              = storeSelfEntityValue(parser, parser->m_declEntity);\n          if (result != XML_ERROR_NONE)\n            return result;\n\n          if (parser->m_entityDeclHandler) {\n            *eventEndPP = s;\n            parser->m_entityDeclHandler(\n                parser->m_handlerArg, parser->m_declEntity->name,\n                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,\n                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);\n            handleDefault = XML_FALSE;\n          }\n        }\n#endif\n      }\n      break;\n    case XML_ROLE_DOCTYPE_SYSTEM_ID:\n#ifdef XML_DTD\n      parser->m_useForeignDTD = XML_FALSE;\n#endif /* XML_DTD */\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (parser->m_startDoctypeDeclHandler) {\n        parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,\n                                                 s + enc->minBytesPerChar,\n                                                 next - enc->minBytesPerChar);\n        if (parser->m_doctypeSysid == NULL)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n#ifdef XML_DTD\n      else\n        /* use externalSubsetName to make parser->m_doctypeSysid non-NULL\n           for the case where no parser->m_startDoctypeDeclHandler is set */\n        parser->m_doctypeSysid = externalSubsetName;\n#endif /* XML_DTD */\n      if (! dtd->standalone\n#ifdef XML_DTD\n          && ! parser->m_paramEntityParsing\n#endif /* XML_DTD */\n          && parser->m_notStandaloneHandler\n          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n        return XML_ERROR_NOT_STANDALONE;\n#ifndef XML_DTD\n      break;\n#else  /* XML_DTD */\n      if (! parser->m_declEntity) {\n        parser->m_declEntity = (ENTITY *)lookup(\n            parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity->publicId = NULL;\n      }\n#endif /* XML_DTD */\n      /* fall through */\n    case XML_ROLE_ENTITY_SYSTEM_ID:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        parser->m_declEntity->systemId\n            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                              next - enc->minBytesPerChar);\n        if (! parser->m_declEntity->systemId)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity->base = parser->m_curBase;\n        poolFinish(&dtd->pool);\n        /* Don't suppress the default handler if we fell through from\n         * the XML_ROLE_DOCTYPE_SYSTEM_ID case.\n         */\n        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_ENTITY_COMPLETE:\n#if XML_GE == 0\n      // This will store \"&amp;entity123;\" in entity->textPtr\n      // to end up as \"&entity123;\" in the handler.\n      if (parser->m_declEntity != NULL) {\n        const enum XML_Error result\n            = storeSelfEntityValue(parser, parser->m_declEntity);\n        if (result != XML_ERROR_NONE)\n          return result;\n      }\n#endif\n      if (dtd->keepProcessing && parser->m_declEntity\n          && parser->m_entityDeclHandler) {\n        *eventEndPP = s;\n        parser->m_entityDeclHandler(\n            parser->m_handlerArg, parser->m_declEntity->name,\n            parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,\n            parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_ENTITY_NOTATION_NAME:\n      if (dtd->keepProcessing && parser->m_declEntity) {\n        parser->m_declEntity->notation\n            = poolStoreString(&dtd->pool, enc, s, next);\n        if (! parser->m_declEntity->notation)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&dtd->pool);\n        if (parser->m_unparsedEntityDeclHandler) {\n          *eventEndPP = s;\n          parser->m_unparsedEntityDeclHandler(\n              parser->m_handlerArg, parser->m_declEntity->name,\n              parser->m_declEntity->base, parser->m_declEntity->systemId,\n              parser->m_declEntity->publicId, parser->m_declEntity->notation);\n          handleDefault = XML_FALSE;\n        } else if (parser->m_entityDeclHandler) {\n          *eventEndPP = s;\n          parser->m_entityDeclHandler(\n              parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,\n              parser->m_declEntity->base, parser->m_declEntity->systemId,\n              parser->m_declEntity->publicId, parser->m_declEntity->notation);\n          handleDefault = XML_FALSE;\n        }\n      }\n      break;\n    case XML_ROLE_GENERAL_ENTITY_NAME: {\n      if (XmlPredefinedEntityName(enc, s, next)) {\n        parser->m_declEntity = NULL;\n        break;\n      }\n      if (dtd->keepProcessing) {\n        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,\n                                                name, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_declEntity->name != name) {\n          poolDiscard(&dtd->pool);\n          parser->m_declEntity = NULL;\n        } else {\n          poolFinish(&dtd->pool);\n          parser->m_declEntity->publicId = NULL;\n          parser->m_declEntity->is_param = XML_FALSE;\n          /* if we have a parent parser or are reading an internal parameter\n             entity, then the entity declaration is not considered \"internal\"\n          */\n          parser->m_declEntity->is_internal\n              = ! (parser->m_parentParser || parser->m_openInternalEntities);\n          if (parser->m_entityDeclHandler)\n            handleDefault = XML_FALSE;\n        }\n      } else {\n        poolDiscard(&dtd->pool);\n        parser->m_declEntity = NULL;\n      }\n    } break;\n    case XML_ROLE_PARAM_ENTITY_NAME:\n#ifdef XML_DTD\n      if (dtd->keepProcessing) {\n        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,\n                                                name, sizeof(ENTITY));\n        if (! parser->m_declEntity)\n          return XML_ERROR_NO_MEMORY;\n        if (parser->m_declEntity->name != name) {\n          poolDiscard(&dtd->pool);\n          parser->m_declEntity = NULL;\n        } else {\n          poolFinish(&dtd->pool);\n          parser->m_declEntity->publicId = NULL;\n          parser->m_declEntity->is_param = XML_TRUE;\n          /* if we have a parent parser or are reading an internal parameter\n             entity, then the entity declaration is not considered \"internal\"\n          */\n          parser->m_declEntity->is_internal\n              = ! (parser->m_parentParser || parser->m_openInternalEntities);\n          if (parser->m_entityDeclHandler)\n            handleDefault = XML_FALSE;\n        }\n      } else {\n        poolDiscard(&dtd->pool);\n        parser->m_declEntity = NULL;\n      }\n#else  /* not XML_DTD */\n      parser->m_declEntity = NULL;\n#endif /* XML_DTD */\n      break;\n    case XML_ROLE_NOTATION_NAME:\n      parser->m_declNotationPublicId = NULL;\n      parser->m_declNotationName = NULL;\n      if (parser->m_notationDeclHandler) {\n        parser->m_declNotationName\n            = poolStoreString(&parser->m_tempPool, enc, s, next);\n        if (! parser->m_declNotationName)\n          return XML_ERROR_NO_MEMORY;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_NOTATION_PUBLIC_ID:\n      if (! XmlIsPublicId(enc, s, next, eventPP))\n        return XML_ERROR_PUBLICID;\n      if (parser\n              ->m_declNotationName) { /* means m_notationDeclHandler != NULL */\n        XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,\n                                        s + enc->minBytesPerChar,\n                                        next - enc->minBytesPerChar);\n        if (! tem)\n          return XML_ERROR_NO_MEMORY;\n        normalizePublicId(tem);\n        parser->m_declNotationPublicId = tem;\n        poolFinish(&parser->m_tempPool);\n        handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_NOTATION_SYSTEM_ID:\n      if (parser->m_declNotationName && parser->m_notationDeclHandler) {\n        const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,\n                                                   s + enc->minBytesPerChar,\n                                                   next - enc->minBytesPerChar);\n        if (! systemId)\n          return XML_ERROR_NO_MEMORY;\n        *eventEndPP = s;\n        parser->m_notationDeclHandler(\n            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,\n            systemId, parser->m_declNotationPublicId);\n        handleDefault = XML_FALSE;\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_NOTATION_NO_SYSTEM_ID:\n      if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {\n        *eventEndPP = s;\n        parser->m_notationDeclHandler(\n            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,\n            0, parser->m_declNotationPublicId);\n        handleDefault = XML_FALSE;\n      }\n      poolClear(&parser->m_tempPool);\n      break;\n    case XML_ROLE_ERROR:\n      switch (tok) {\n      case XML_TOK_PARAM_ENTITY_REF:\n        /* PE references in internal subset are\n           not allowed within declarations. */\n        return XML_ERROR_PARAM_ENTITY_REF;\n      case XML_TOK_XML_DECL:\n        return XML_ERROR_MISPLACED_XML_PI;\n      default:\n        return XML_ERROR_SYNTAX;\n      }\n#ifdef XML_DTD\n    case XML_ROLE_IGNORE_SECT: {\n      enum XML_Error result;\n      if (parser->m_defaultHandler)\n        reportDefault(parser, enc, s, next);\n      handleDefault = XML_FALSE;\n      result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);\n      if (result != XML_ERROR_NONE)\n        return result;\n      else if (! next) {\n        parser->m_processor = ignoreSectionProcessor;\n        return result;\n      }\n    } break;\n#endif /* XML_DTD */\n    case XML_ROLE_GROUP_OPEN:\n      if (parser->m_prologState.level >= parser->m_groupSize) {\n        if (parser->m_groupSize) {\n          {\n            /* Detect and prevent integer overflow */\n            if (parser->m_groupSize > (unsigned int)(-1) / 2u) {\n              return XML_ERROR_NO_MEMORY;\n            }\n\n            char *const new_connector = REALLOC(\n                parser, parser->m_groupConnector, parser->m_groupSize *= 2);\n            if (new_connector == NULL) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n            parser->m_groupConnector = new_connector;\n          }\n\n          if (dtd->scaffIndex) {\n            /* Detect and prevent integer overflow.\n             * The preprocessor guard addresses the \"always false\" warning\n             * from -Wtype-limits on platforms where\n             * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n            if (parser->m_groupSize > SIZE_MAX / sizeof(int)) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n#endif\n\n            int *const new_scaff_index = REALLOC(\n                parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));\n            if (new_scaff_index == NULL) {\n              parser->m_groupSize /= 2;\n              return XML_ERROR_NO_MEMORY;\n            }\n            dtd->scaffIndex = new_scaff_index;\n          }\n        } else {\n          parser->m_groupConnector = MALLOC(parser, parser->m_groupSize = 32);\n          if (! parser->m_groupConnector) {\n            parser->m_groupSize = 0;\n            return XML_ERROR_NO_MEMORY;\n          }\n        }\n      }\n      parser->m_groupConnector[parser->m_prologState.level] = 0;\n      if (dtd->in_eldecl) {\n        int myindex = nextScaffoldPart(parser);\n        if (myindex < 0)\n          return XML_ERROR_NO_MEMORY;\n        assert(dtd->scaffIndex != NULL);\n        dtd->scaffIndex[dtd->scaffLevel] = myindex;\n        dtd->scaffLevel++;\n        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n    case XML_ROLE_GROUP_SEQUENCE:\n      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)\n        return XML_ERROR_SYNTAX;\n      parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;\n      if (dtd->in_eldecl && parser->m_elementDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_GROUP_CHOICE:\n      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)\n        return XML_ERROR_SYNTAX;\n      if (dtd->in_eldecl\n          && ! parser->m_groupConnector[parser->m_prologState.level]\n          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n              != XML_CTYPE_MIXED)) {\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n            = XML_CTYPE_CHOICE;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;\n      break;\n    case XML_ROLE_PARAM_ENTITY_REF:\n#ifdef XML_DTD\n    case XML_ROLE_INNER_PARAM_ENTITY_REF:\n      dtd->hasParamEntityRefs = XML_TRUE;\n      if (! parser->m_paramEntityParsing)\n        dtd->keepProcessing = dtd->standalone;\n      else {\n        const XML_Char *name;\n        ENTITY *entity;\n        name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,\n                               next - enc->minBytesPerChar);\n        if (! name)\n          return XML_ERROR_NO_MEMORY;\n        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);\n        poolDiscard(&dtd->pool);\n        /* first, determine if a check for an existing declaration is needed;\n           if yes, check that the entity exists, and that it is internal,\n           otherwise call the skipped entity handler\n        */\n        if (parser->m_prologState.documentEntity\n            && (dtd->standalone ? ! parser->m_openInternalEntities\n                                : ! dtd->hasParamEntityRefs)) {\n          if (! entity)\n            return XML_ERROR_UNDEFINED_ENTITY;\n          else if (! entity->is_internal) {\n            /* It's hard to exhaustively search the code to be sure,\n             * but there doesn't seem to be a way of executing the\n             * following line.  There are two cases:\n             *\n             * If 'standalone' is false, the DTD must have no\n             * parameter entities or we wouldn't have passed the outer\n             * 'if' statement.  That means the only entity in the hash\n             * table is the external subset name \"#\" which cannot be\n             * given as a parameter entity name in XML syntax, so the\n             * lookup must have returned NULL and we don't even reach\n             * the test for an internal entity.\n             *\n             * If 'standalone' is true, it does not seem to be\n             * possible to create entities taking this code path that\n             * are not internal entities, so fail the test above.\n             *\n             * Because this analysis is very uncertain, the code is\n             * being left in place and merely removed from the\n             * coverage test statistics.\n             */\n            return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */\n          }\n        } else if (! entity) {\n          dtd->keepProcessing = dtd->standalone;\n          /* cannot report skipped entities in declarations */\n          if ((role == XML_ROLE_PARAM_ENTITY_REF)\n              && parser->m_skippedEntityHandler) {\n            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);\n            handleDefault = XML_FALSE;\n          }\n          break;\n        }\n        if (entity->open)\n          return XML_ERROR_RECURSIVE_ENTITY_REF;\n        if (entity->textPtr) {\n          enum XML_Error result;\n          XML_Bool betweenDecl\n              = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);\n          result = processEntity(parser, entity, betweenDecl, ENTITY_INTERNAL);\n          if (result != XML_ERROR_NONE)\n            return result;\n          handleDefault = XML_FALSE;\n          break;\n        }\n        if (parser->m_externalEntityRefHandler) {\n          dtd->paramEntityRead = XML_FALSE;\n          entity->open = XML_TRUE;\n          entityTrackingOnOpen(parser, entity, __LINE__);\n          if (! parser->m_externalEntityRefHandler(\n                  parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                  entity->systemId, entity->publicId)) {\n            entityTrackingOnClose(parser, entity, __LINE__);\n            entity->open = XML_FALSE;\n            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n          }\n          entityTrackingOnClose(parser, entity, __LINE__);\n          entity->open = XML_FALSE;\n          handleDefault = XML_FALSE;\n          if (! dtd->paramEntityRead) {\n            dtd->keepProcessing = dtd->standalone;\n            break;\n          }\n        } else {\n          dtd->keepProcessing = dtd->standalone;\n          break;\n        }\n      }\n#endif /* XML_DTD */\n      if (! dtd->standalone && parser->m_notStandaloneHandler\n          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))\n        return XML_ERROR_NOT_STANDALONE;\n      break;\n\n      /* Element declaration stuff */\n\n    case XML_ROLE_ELEMENT_NAME:\n      if (parser->m_elementDeclHandler) {\n        parser->m_declElementType = getElementType(parser, enc, s, next);\n        if (! parser->m_declElementType)\n          return XML_ERROR_NO_MEMORY;\n        dtd->scaffLevel = 0;\n        dtd->scaffCount = 0;\n        dtd->in_eldecl = XML_TRUE;\n        handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_ANY:\n    case XML_ROLE_CONTENT_EMPTY:\n      if (dtd->in_eldecl) {\n        if (parser->m_elementDeclHandler) {\n          // NOTE: We are avoiding MALLOC(..) here to so that\n          //       applications that are not using XML_FreeContentModel but\n          //       plain free(..) or .free_fcn() to free the content model's\n          //       memory are safe.\n          XML_Content *content = parser->m_mem.malloc_fcn(sizeof(XML_Content));\n          if (! content)\n            return XML_ERROR_NO_MEMORY;\n          content->quant = XML_CQUANT_NONE;\n          content->name = NULL;\n          content->numchildren = 0;\n          content->children = NULL;\n          content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY\n                                                          : XML_CTYPE_EMPTY);\n          *eventEndPP = s;\n          parser->m_elementDeclHandler(\n              parser->m_handlerArg, parser->m_declElementType->name, content);\n          handleDefault = XML_FALSE;\n        }\n        dtd->in_eldecl = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_PCDATA:\n      if (dtd->in_eldecl) {\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type\n            = XML_CTYPE_MIXED;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_CONTENT_ELEMENT:\n      quant = XML_CQUANT_NONE;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_OPT:\n      quant = XML_CQUANT_OPT;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_REP:\n      quant = XML_CQUANT_REP;\n      goto elementContent;\n    case XML_ROLE_CONTENT_ELEMENT_PLUS:\n      quant = XML_CQUANT_PLUS;\n    elementContent:\n      if (dtd->in_eldecl) {\n        ELEMENT_TYPE *el;\n        const XML_Char *name;\n        size_t nameLen;\n        const char *nxt\n            = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);\n        int myindex = nextScaffoldPart(parser);\n        if (myindex < 0)\n          return XML_ERROR_NO_MEMORY;\n        dtd->scaffold[myindex].type = XML_CTYPE_NAME;\n        dtd->scaffold[myindex].quant = quant;\n        el = getElementType(parser, enc, s, nxt);\n        if (! el)\n          return XML_ERROR_NO_MEMORY;\n        name = el->name;\n        dtd->scaffold[myindex].name = name;\n        nameLen = 0;\n        while (name[nameLen++])\n          ;\n\n        /* Detect and prevent integer overflow */\n        if (nameLen > UINT_MAX - dtd->contentStringLen) {\n          return XML_ERROR_NO_MEMORY;\n        }\n\n        dtd->contentStringLen += (unsigned)nameLen;\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n      }\n      break;\n\n    case XML_ROLE_GROUP_CLOSE:\n      quant = XML_CQUANT_NONE;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_OPT:\n      quant = XML_CQUANT_OPT;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_REP:\n      quant = XML_CQUANT_REP;\n      goto closeGroup;\n    case XML_ROLE_GROUP_CLOSE_PLUS:\n      quant = XML_CQUANT_PLUS;\n    closeGroup:\n      if (dtd->in_eldecl) {\n        if (parser->m_elementDeclHandler)\n          handleDefault = XML_FALSE;\n        dtd->scaffLevel--;\n        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;\n        if (dtd->scaffLevel == 0) {\n          if (! handleDefault) {\n            XML_Content *model = build_model(parser);\n            if (! model)\n              return XML_ERROR_NO_MEMORY;\n            *eventEndPP = s;\n            parser->m_elementDeclHandler(\n                parser->m_handlerArg, parser->m_declElementType->name, model);\n          }\n          dtd->in_eldecl = XML_FALSE;\n          dtd->contentStringLen = 0;\n        }\n      }\n      break;\n      /* End element declaration stuff */\n\n    case XML_ROLE_PI:\n      if (! reportProcessingInstruction(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_COMMENT:\n      if (! reportComment(parser, enc, s, next))\n        return XML_ERROR_NO_MEMORY;\n      handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_NONE:\n      switch (tok) {\n      case XML_TOK_BOM:\n        handleDefault = XML_FALSE;\n        break;\n      }\n      break;\n    case XML_ROLE_DOCTYPE_NONE:\n      if (parser->m_startDoctypeDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ENTITY_NONE:\n      if (dtd->keepProcessing && parser->m_entityDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_NOTATION_NONE:\n      if (parser->m_notationDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ATTLIST_NONE:\n      if (dtd->keepProcessing && parser->m_attlistDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    case XML_ROLE_ELEMENT_NONE:\n      if (parser->m_elementDeclHandler)\n        handleDefault = XML_FALSE;\n      break;\n    } /* end of big switch */\n\n    if (handleDefault && parser->m_defaultHandler)\n      reportDefault(parser, enc, s, next);\n\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        *nextPtr = next;\n        return XML_ERROR_NONE;\n      }\n    /* Fall through */\n    default:\n      s = next;\n      tok = XmlPrologTok(enc, s, end, &next);\n    }\n  }\n  /* not reached */\n}\n\nstatic enum XML_Error PTRCALL\nepilogProcessor(XML_Parser parser, const char *s, const char *end,\n                const char **nextPtr) {\n  parser->m_processor = epilogProcessor;\n  parser->m_eventPtr = s;\n  for (;;) {\n    const char *next = NULL;\n    int tok = XmlPrologTok(parser->m_encoding, s, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,\n                                  XML_ACCOUNT_DIRECT)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    parser->m_eventEndPtr = next;\n    switch (tok) {\n    /* report partial linebreak - it might be the last token */\n    case -XML_TOK_PROLOG_S:\n      if (parser->m_defaultHandler) {\n        reportDefault(parser, parser->m_encoding, s, next);\n        if (parser->m_parsingStatus.parsing == XML_FINISHED)\n          return XML_ERROR_ABORTED;\n      }\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_TOK_NONE:\n      *nextPtr = s;\n      return XML_ERROR_NONE;\n    case XML_TOK_PROLOG_S:\n      if (parser->m_defaultHandler)\n        reportDefault(parser, parser->m_encoding, s, next);\n      break;\n    case XML_TOK_PI:\n      if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_COMMENT:\n      if (! reportComment(parser, parser->m_encoding, s, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_INVALID:\n      parser->m_eventPtr = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (! parser->m_parsingStatus.finalBuffer) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_UNCLOSED_TOKEN;\n    case XML_TOK_PARTIAL_CHAR:\n      if (! parser->m_parsingStatus.finalBuffer) {\n        *nextPtr = s;\n        return XML_ERROR_NONE;\n      }\n      return XML_ERROR_PARTIAL_CHAR;\n    default:\n      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;\n    }\n    switch (parser->m_parsingStatus.parsing) {\n    case XML_SUSPENDED:\n      parser->m_eventPtr = next;\n      *nextPtr = next;\n      return XML_ERROR_NONE;\n    case XML_FINISHED:\n      parser->m_eventPtr = next;\n      return XML_ERROR_ABORTED;\n    case XML_PARSING:\n      if (parser->m_reenter) {\n        return XML_ERROR_UNEXPECTED_STATE; // LCOV_EXCL_LINE\n      }\n    /* Fall through */\n    default:;\n      parser->m_eventPtr = s = next;\n    }\n  }\n}\n\nstatic enum XML_Error\nprocessEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl,\n              enum EntityType type) {\n  OPEN_INTERNAL_ENTITY *openEntity, **openEntityList, **freeEntityList;\n  switch (type) {\n  case ENTITY_INTERNAL:\n    parser->m_processor = internalEntityProcessor;\n    openEntityList = &parser->m_openInternalEntities;\n    freeEntityList = &parser->m_freeInternalEntities;\n    break;\n  case ENTITY_ATTRIBUTE:\n    openEntityList = &parser->m_openAttributeEntities;\n    freeEntityList = &parser->m_freeAttributeEntities;\n    break;\n  case ENTITY_VALUE:\n    openEntityList = &parser->m_openValueEntities;\n    freeEntityList = &parser->m_freeValueEntities;\n    break;\n    /* default case serves merely as a safety net in case of a\n     * wrong entityType. Therefore we exclude the following lines\n     * from the test coverage.\n     *\n     * LCOV_EXCL_START\n     */\n  default:\n    // Should not reach here\n    assert(0);\n    /* LCOV_EXCL_STOP */\n  }\n\n  if (*freeEntityList) {\n    openEntity = *freeEntityList;\n    *freeEntityList = openEntity->next;\n  } else {\n    openEntity = MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));\n    if (! openEntity)\n      return XML_ERROR_NO_MEMORY;\n  }\n  entity->open = XML_TRUE;\n  entity->hasMore = XML_TRUE;\n#if XML_GE == 1\n  entityTrackingOnOpen(parser, entity, __LINE__);\n#endif\n  entity->processed = 0;\n  openEntity->next = *openEntityList;\n  *openEntityList = openEntity;\n  openEntity->entity = entity;\n  openEntity->type = type;\n  openEntity->startTagLevel = parser->m_tagLevel;\n  openEntity->betweenDecl = betweenDecl;\n  openEntity->internalEventPtr = NULL;\n  openEntity->internalEventEndPtr = NULL;\n\n  // Only internal entities make use of the reenter flag\n  // therefore no need to set it for other entity types\n  if (type == ENTITY_INTERNAL) {\n    triggerReenter(parser);\n  }\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error PTRCALL\ninternalEntityProcessor(XML_Parser parser, const char *s, const char *end,\n                        const char **nextPtr) {\n  UNUSED_P(s);\n  UNUSED_P(end);\n  UNUSED_P(nextPtr);\n  ENTITY *entity;\n  const char *textStart, *textEnd;\n  const char *next;\n  enum XML_Error result;\n  OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;\n  if (! openEntity)\n    return XML_ERROR_UNEXPECTED_STATE;\n\n  entity = openEntity->entity;\n\n  // This will return early\n  if (entity->hasMore) {\n    textStart = ((const char *)entity->textPtr) + entity->processed;\n    textEnd = (const char *)(entity->textPtr + entity->textLen);\n    /* Set a safe default value in case 'next' does not get set */\n    next = textStart;\n\n    if (entity->is_param) {\n      int tok\n          = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);\n      result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,\n                        tok, next, &next, XML_FALSE, XML_FALSE,\n                        XML_ACCOUNT_ENTITY_EXPANSION);\n    } else {\n      result = doContent(parser, openEntity->startTagLevel,\n                         parser->m_internalEncoding, textStart, textEnd, &next,\n                         XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION);\n    }\n\n    if (result != XML_ERROR_NONE)\n      return result;\n    // Check if entity is complete, if not, mark down how much of it is\n    // processed\n    if (textEnd != next\n        && (parser->m_parsingStatus.parsing == XML_SUSPENDED\n            || (parser->m_parsingStatus.parsing == XML_PARSING\n                && parser->m_reenter))) {\n      entity->processed = (int)(next - (const char *)entity->textPtr);\n      return result;\n    }\n\n    // Entity is complete. We cannot close it here since we need to first\n    // process its possible inner entities (which are added to the\n    // m_openInternalEntities during doProlog or doContent calls above)\n    entity->hasMore = XML_FALSE;\n    if (! entity->is_param\n        && (openEntity->startTagLevel != parser->m_tagLevel)) {\n      return XML_ERROR_ASYNC_ENTITY;\n    }\n    triggerReenter(parser);\n    return result;\n  } // End of entity processing, \"if\" block will return here\n\n  // Remove fully processed openEntity from open entity list.\n#if XML_GE == 1\n  entityTrackingOnClose(parser, entity, __LINE__);\n#endif\n  // openEntity is m_openInternalEntities' head, as we set it at the start of\n  // this function and we skipped doProlog and doContent calls with hasMore set\n  // to false. This means we can directly remove the head of\n  // m_openInternalEntities\n  assert(parser->m_openInternalEntities == openEntity);\n  entity->open = XML_FALSE;\n  parser->m_openInternalEntities = parser->m_openInternalEntities->next;\n\n  /* put openEntity back in list of free instances */\n  openEntity->next = parser->m_freeInternalEntities;\n  parser->m_freeInternalEntities = openEntity;\n\n  if (parser->m_openInternalEntities == NULL) {\n    parser->m_processor = entity->is_param ? prologProcessor : contentProcessor;\n  }\n  triggerReenter(parser);\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error PTRCALL\nerrorProcessor(XML_Parser parser, const char *s, const char *end,\n               const char **nextPtr) {\n  UNUSED_P(s);\n  UNUSED_P(end);\n  UNUSED_P(nextPtr);\n  return parser->m_errorCode;\n}\n\nstatic enum XML_Error\nstoreAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                    const char *ptr, const char *end, STRING_POOL *pool,\n                    enum XML_Account account) {\n  const char *next = ptr;\n  enum XML_Error result = XML_ERROR_NONE;\n\n  while (1) {\n    if (! parser->m_openAttributeEntities) {\n      result = appendAttributeValue(parser, enc, isCdata, next, end, pool,\n                                    account, &next);\n    } else {\n      OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openAttributeEntities;\n      if (! openEntity)\n        return XML_ERROR_UNEXPECTED_STATE;\n\n      ENTITY *const entity = openEntity->entity;\n      const char *const textStart\n          = ((const char *)entity->textPtr) + entity->processed;\n      const char *const textEnd\n          = (const char *)(entity->textPtr + entity->textLen);\n      /* Set a safe default value in case 'next' does not get set */\n      const char *nextInEntity = textStart;\n      if (entity->hasMore) {\n        result = appendAttributeValue(\n            parser, parser->m_internalEncoding, isCdata, textStart, textEnd,\n            pool, XML_ACCOUNT_ENTITY_EXPANSION, &nextInEntity);\n        if (result != XML_ERROR_NONE)\n          break;\n        // Check if entity is complete, if not, mark down how much of it is\n        // processed. A XML_SUSPENDED check here is not required as\n        // appendAttributeValue will never suspend the parser.\n        if (textEnd != nextInEntity) {\n          entity->processed\n              = (int)(nextInEntity - (const char *)entity->textPtr);\n          continue;\n        }\n\n        // Entity is complete. We cannot close it here since we need to first\n        // process its possible inner entities (which are added to the\n        // m_openAttributeEntities during appendAttributeValue)\n        entity->hasMore = XML_FALSE;\n        continue;\n      } // End of entity processing, \"if\" block skips the rest\n\n      // Remove fully processed openEntity from open entity list.\n#if XML_GE == 1\n      entityTrackingOnClose(parser, entity, __LINE__);\n#endif\n      // openEntity is m_openAttributeEntities' head, since we set it at the\n      // start of this function and because we skipped appendAttributeValue call\n      // with hasMore set to false. This means we can directly remove the head\n      // of m_openAttributeEntities\n      assert(parser->m_openAttributeEntities == openEntity);\n      entity->open = XML_FALSE;\n      parser->m_openAttributeEntities = parser->m_openAttributeEntities->next;\n\n      /* put openEntity back in list of free instances */\n      openEntity->next = parser->m_freeAttributeEntities;\n      parser->m_freeAttributeEntities = openEntity;\n    }\n\n    // Break if an error occurred or there is nothing left to process\n    if (result || (parser->m_openAttributeEntities == NULL && end == next)) {\n      break;\n    }\n  }\n\n  if (result)\n    return result;\n  if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)\n    poolChop(pool);\n  if (! poolAppendChar(pool, XML_T('\\0')))\n    return XML_ERROR_NO_MEMORY;\n  return XML_ERROR_NONE;\n}\n\nstatic enum XML_Error\nappendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,\n                     const char *ptr, const char *end, STRING_POOL *pool,\n                     enum XML_Account account, const char **nextPtr) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n#ifndef XML_DTD\n  UNUSED_P(account);\n#endif\n\n  for (;;) {\n    const char *next\n        = ptr; /* XmlAttributeValueTok doesn't always set the last arg */\n    int tok = XmlAttributeValueTok(enc, ptr, end, &next);\n#if XML_GE == 1\n    if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {\n      accountingOnAbort(parser);\n      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n    }\n#endif\n    switch (tok) {\n    case XML_TOK_NONE:\n      if (nextPtr) {\n        *nextPtr = next;\n      }\n      return XML_ERROR_NONE;\n    case XML_TOK_INVALID:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = next;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_PARTIAL:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = ptr;\n      return XML_ERROR_INVALID_TOKEN;\n    case XML_TOK_CHAR_REF: {\n      XML_Char buf[XML_ENCODE_MAX];\n      int i;\n      int n = XmlCharRefNumber(enc, ptr);\n      if (n < 0) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_BAD_CHAR_REF;\n      }\n      if (! isCdata && n == 0x20 /* space */\n          && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\n        break;\n      n = XmlEncode(n, (ICHAR *)buf);\n      /* The XmlEncode() functions can never return 0 here.  That\n       * error return happens if the code point passed in is either\n       * negative or greater than or equal to 0x110000.  The\n       * XmlCharRefNumber() functions will all return a number\n       * strictly less than 0x110000 or a negative value if an error\n       * occurred.  The negative value is intercepted above, so\n       * XmlEncode() is never passed a value it might return an\n       * error for.\n       */\n      for (i = 0; i < n; i++) {\n        if (! poolAppendChar(pool, buf[i]))\n          return XML_ERROR_NO_MEMORY;\n      }\n    } break;\n    case XML_TOK_DATA_CHARS:\n      if (! poolAppend(pool, enc, ptr, next))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_TRAILING_CR:\n      next = ptr + enc->minBytesPerChar;\n      /* fall through */\n    case XML_TOK_ATTRIBUTE_VALUE_S:\n    case XML_TOK_DATA_NEWLINE:\n      if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))\n        break;\n      if (! poolAppendChar(pool, 0x20))\n        return XML_ERROR_NO_MEMORY;\n      break;\n    case XML_TOK_ENTITY_REF: {\n      const XML_Char *name;\n      ENTITY *entity;\n      bool checkEntityDecl;\n      XML_Char ch = (XML_Char)XmlPredefinedEntityName(\n          enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);\n      if (ch) {\n#if XML_GE == 1\n        /* NOTE: We are replacing 4-6 characters original input for 1 character\n         *       so there is no amplification and hence recording without\n         *       protection. */\n        accountingDiffTolerated(parser, tok, (char *)&ch,\n                                ((char *)&ch) + sizeof(XML_Char), __LINE__,\n                                XML_ACCOUNT_ENTITY_EXPANSION);\n#endif /* XML_GE == 1 */\n        if (! poolAppendChar(pool, ch))\n          return XML_ERROR_NO_MEMORY;\n        break;\n      }\n      name = poolStoreString(&parser->m_temp2Pool, enc,\n                             ptr + enc->minBytesPerChar,\n                             next - enc->minBytesPerChar);\n      if (! name)\n        return XML_ERROR_NO_MEMORY;\n      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);\n      poolDiscard(&parser->m_temp2Pool);\n      /* First, determine if a check for an existing declaration is needed;\n         if yes, check that the entity exists, and that it is internal.\n      */\n      if (pool == &dtd->pool) /* are we called from prolog? */\n        checkEntityDecl =\n#ifdef XML_DTD\n            parser->m_prologState.documentEntity &&\n#endif /* XML_DTD */\n            (dtd->standalone ? ! parser->m_openInternalEntities\n                             : ! dtd->hasParamEntityRefs);\n      else /* if (pool == &parser->m_tempPool): we are called from content */\n        checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;\n      if (checkEntityDecl) {\n        if (! entity)\n          return XML_ERROR_UNDEFINED_ENTITY;\n        else if (! entity->is_internal)\n          return XML_ERROR_ENTITY_DECLARED_IN_PE;\n      } else if (! entity) {\n        /* Cannot report skipped entity here - see comments on\n           parser->m_skippedEntityHandler.\n        if (parser->m_skippedEntityHandler)\n          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n        */\n        /* Cannot call the default handler because this would be\n           out of sync with the call to the startElementHandler.\n        if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)\n          reportDefault(parser, enc, ptr, next);\n        */\n        break;\n      }\n      if (entity->open) {\n        if (enc == parser->m_encoding) {\n          /* It does not appear that this line can be executed.\n           *\n           * The \"if (entity->open)\" check catches recursive entity\n           * definitions.  In order to be called with an open\n           * entity, it must have gone through this code before and\n           * been through the recursive call to\n           * appendAttributeValue() some lines below.  That call\n           * sets the local encoding (\"enc\") to the parser's\n           * internal encoding (internal_utf8 or internal_utf16),\n           * which can never be the same as the principle encoding.\n           * It doesn't appear there is another code path that gets\n           * here with entity->open being TRUE.\n           *\n           * Since it is not certain that this logic is watertight,\n           * we keep the line and merely exclude it from coverage\n           * tests.\n           */\n          parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */\n        }\n        return XML_ERROR_RECURSIVE_ENTITY_REF;\n      }\n      if (entity->notation) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_BINARY_ENTITY_REF;\n      }\n      if (! entity->textPtr) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = ptr;\n        return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;\n      } else {\n        enum XML_Error result;\n        result = processEntity(parser, entity, XML_FALSE, ENTITY_ATTRIBUTE);\n        if ((result == XML_ERROR_NONE) && (nextPtr != NULL)) {\n          *nextPtr = next;\n        }\n        return result;\n      }\n    } break;\n    default:\n      /* The only token returned by XmlAttributeValueTok() that does\n       * not have an explicit case here is XML_TOK_PARTIAL_CHAR.\n       * Getting that would require an entity name to contain an\n       * incomplete XML character (e.g. \\xE2\\x82); however previous\n       * tokenisers will have already recognised and rejected such\n       * names before XmlAttributeValueTok() gets a look-in.  This\n       * default case should be retained as a safety net, but the code\n       * excluded from coverage tests.\n       *\n       * LCOV_EXCL_START\n       */\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = ptr;\n      return XML_ERROR_UNEXPECTED_STATE;\n      /* LCOV_EXCL_STOP */\n    }\n    ptr = next;\n  }\n  /* not reached */\n}\n\n#if XML_GE == 1\nstatic enum XML_Error\nstoreEntityValue(XML_Parser parser, const ENCODING *enc,\n                 const char *entityTextPtr, const char *entityTextEnd,\n                 enum XML_Account account, const char **nextPtr) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  STRING_POOL *pool = &(dtd->entityValuePool);\n  enum XML_Error result = XML_ERROR_NONE;\n#  ifdef XML_DTD\n  int oldInEntityValue = parser->m_prologState.inEntityValue;\n  parser->m_prologState.inEntityValue = 1;\n#  else\n  UNUSED_P(account);\n#  endif /* XML_DTD */\n  /* never return Null for the value argument in EntityDeclHandler,\n     since this would indicate an external entity; therefore we\n     have to make sure that entityValuePool.start is not null */\n  if (! pool->blocks) {\n    if (! poolGrow(pool))\n      return XML_ERROR_NO_MEMORY;\n  }\n\n  const char *next = entityTextPtr;\n\n  /* Nothing to tokenize. */\n  if (entityTextPtr >= entityTextEnd) {\n    result = XML_ERROR_NONE;\n    goto endEntityValue;\n  }\n\n  for (;;) {\n    next\n        = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */\n    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);\n\n    if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,\n                                  account)) {\n      accountingOnAbort(parser);\n      result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH;\n      goto endEntityValue;\n    }\n\n    switch (tok) {\n    case XML_TOK_PARAM_ENTITY_REF:\n#  ifdef XML_DTD\n      if (parser->m_isParamEntity || enc != parser->m_encoding) {\n        const XML_Char *name;\n        ENTITY *entity;\n        name = poolStoreString(&parser->m_tempPool, enc,\n                               entityTextPtr + enc->minBytesPerChar,\n                               next - enc->minBytesPerChar);\n        if (! name) {\n          result = XML_ERROR_NO_MEMORY;\n          goto endEntityValue;\n        }\n        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);\n        poolDiscard(&parser->m_tempPool);\n        if (! entity) {\n          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */\n          /* cannot report skipped entity here - see comments on\n             parser->m_skippedEntityHandler\n          if (parser->m_skippedEntityHandler)\n            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);\n          */\n          dtd->keepProcessing = dtd->standalone;\n          goto endEntityValue;\n        }\n        if (entity->open || (entity == parser->m_declEntity)) {\n          if (enc == parser->m_encoding)\n            parser->m_eventPtr = entityTextPtr;\n          result = XML_ERROR_RECURSIVE_ENTITY_REF;\n          goto endEntityValue;\n        }\n        if (entity->systemId) {\n          if (parser->m_externalEntityRefHandler) {\n            dtd->paramEntityRead = XML_FALSE;\n            entity->open = XML_TRUE;\n            entityTrackingOnOpen(parser, entity, __LINE__);\n            if (! parser->m_externalEntityRefHandler(\n                    parser->m_externalEntityRefHandlerArg, 0, entity->base,\n                    entity->systemId, entity->publicId)) {\n              entityTrackingOnClose(parser, entity, __LINE__);\n              entity->open = XML_FALSE;\n              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;\n              goto endEntityValue;\n            }\n            entityTrackingOnClose(parser, entity, __LINE__);\n            entity->open = XML_FALSE;\n            if (! dtd->paramEntityRead)\n              dtd->keepProcessing = dtd->standalone;\n          } else\n            dtd->keepProcessing = dtd->standalone;\n        } else {\n          result = processEntity(parser, entity, XML_FALSE, ENTITY_VALUE);\n          goto endEntityValue;\n        }\n        break;\n      }\n#  endif /* XML_DTD */\n      /* In the internal subset, PE references are not legal\n         within markup declarations, e.g entity values in this case. */\n      parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_PARAM_ENTITY_REF;\n      goto endEntityValue;\n    case XML_TOK_NONE:\n      result = XML_ERROR_NONE;\n      goto endEntityValue;\n    case XML_TOK_ENTITY_REF:\n    case XML_TOK_DATA_CHARS:\n      if (! poolAppend(pool, enc, entityTextPtr, next)) {\n        result = XML_ERROR_NO_MEMORY;\n        goto endEntityValue;\n      }\n      break;\n    case XML_TOK_TRAILING_CR:\n      next = entityTextPtr + enc->minBytesPerChar;\n      /* fall through */\n    case XML_TOK_DATA_NEWLINE:\n      if (pool->end == pool->ptr && ! poolGrow(pool)) {\n        result = XML_ERROR_NO_MEMORY;\n        goto endEntityValue;\n      }\n      *(pool->ptr)++ = 0xA;\n      break;\n    case XML_TOK_CHAR_REF: {\n      XML_Char buf[XML_ENCODE_MAX];\n      int i;\n      int n = XmlCharRefNumber(enc, entityTextPtr);\n      if (n < 0) {\n        if (enc == parser->m_encoding)\n          parser->m_eventPtr = entityTextPtr;\n        result = XML_ERROR_BAD_CHAR_REF;\n        goto endEntityValue;\n      }\n      n = XmlEncode(n, (ICHAR *)buf);\n      /* The XmlEncode() functions can never return 0 here.  That\n       * error return happens if the code point passed in is either\n       * negative or greater than or equal to 0x110000.  The\n       * XmlCharRefNumber() functions will all return a number\n       * strictly less than 0x110000 or a negative value if an error\n       * occurred.  The negative value is intercepted above, so\n       * XmlEncode() is never passed a value it might return an\n       * error for.\n       */\n      for (i = 0; i < n; i++) {\n        if (pool->end == pool->ptr && ! poolGrow(pool)) {\n          result = XML_ERROR_NO_MEMORY;\n          goto endEntityValue;\n        }\n        *(pool->ptr)++ = buf[i];\n      }\n    } break;\n    case XML_TOK_PARTIAL:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_INVALID_TOKEN;\n      goto endEntityValue;\n    case XML_TOK_INVALID:\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = next;\n      result = XML_ERROR_INVALID_TOKEN;\n      goto endEntityValue;\n    default:\n      /* This default case should be unnecessary -- all the tokens\n       * that XmlEntityValueTok() can return have their own explicit\n       * cases -- but should be retained for safety.  We do however\n       * exclude it from the coverage statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      if (enc == parser->m_encoding)\n        parser->m_eventPtr = entityTextPtr;\n      result = XML_ERROR_UNEXPECTED_STATE;\n      goto endEntityValue;\n      /* LCOV_EXCL_STOP */\n    }\n    entityTextPtr = next;\n  }\nendEntityValue:\n#  ifdef XML_DTD\n  parser->m_prologState.inEntityValue = oldInEntityValue;\n#  endif /* XML_DTD */\n  // If 'nextPtr' is given, it should be updated during the processing\n  if (nextPtr != NULL) {\n    *nextPtr = next;\n  }\n  return result;\n}\n\nstatic enum XML_Error\ncallStoreEntityValue(XML_Parser parser, const ENCODING *enc,\n                     const char *entityTextPtr, const char *entityTextEnd,\n                     enum XML_Account account) {\n  const char *next = entityTextPtr;\n  enum XML_Error result = XML_ERROR_NONE;\n  while (1) {\n    if (! parser->m_openValueEntities) {\n      result\n          = storeEntityValue(parser, enc, next, entityTextEnd, account, &next);\n    } else {\n      OPEN_INTERNAL_ENTITY *const openEntity = parser->m_openValueEntities;\n      if (! openEntity)\n        return XML_ERROR_UNEXPECTED_STATE;\n\n      ENTITY *const entity = openEntity->entity;\n      const char *const textStart\n          = ((const char *)entity->textPtr) + entity->processed;\n      const char *const textEnd\n          = (const char *)(entity->textPtr + entity->textLen);\n      /* Set a safe default value in case 'next' does not get set */\n      const char *nextInEntity = textStart;\n      if (entity->hasMore) {\n        result = storeEntityValue(parser, parser->m_internalEncoding, textStart,\n                                  textEnd, XML_ACCOUNT_ENTITY_EXPANSION,\n                                  &nextInEntity);\n        if (result != XML_ERROR_NONE)\n          break;\n        // Check if entity is complete, if not, mark down how much of it is\n        // processed. A XML_SUSPENDED check here is not required as\n        // appendAttributeValue will never suspend the parser.\n        if (textEnd != nextInEntity) {\n          entity->processed\n              = (int)(nextInEntity - (const char *)entity->textPtr);\n          continue;\n        }\n\n        // Entity is complete. We cannot close it here since we need to first\n        // process its possible inner entities (which are added to the\n        // m_openValueEntities during storeEntityValue)\n        entity->hasMore = XML_FALSE;\n        continue;\n      } // End of entity processing, \"if\" block skips the rest\n\n      // Remove fully processed openEntity from open entity list.\n#  if XML_GE == 1\n      entityTrackingOnClose(parser, entity, __LINE__);\n#  endif\n      // openEntity is m_openValueEntities' head, since we set it at the\n      // start of this function and because we skipped storeEntityValue call\n      // with hasMore set to false. This means we can directly remove the head\n      // of m_openValueEntities\n      assert(parser->m_openValueEntities == openEntity);\n      entity->open = XML_FALSE;\n      parser->m_openValueEntities = parser->m_openValueEntities->next;\n\n      /* put openEntity back in list of free instances */\n      openEntity->next = parser->m_freeValueEntities;\n      parser->m_freeValueEntities = openEntity;\n    }\n\n    // Break if an error occurred or there is nothing left to process\n    if (result\n        || (parser->m_openValueEntities == NULL && entityTextEnd == next)) {\n      break;\n    }\n  }\n\n  return result;\n}\n\n#else /* XML_GE == 0 */\n\nstatic enum XML_Error\nstoreSelfEntityValue(XML_Parser parser, ENTITY *entity) {\n  // This will store \"&amp;entity123;\" in entity->textPtr\n  // to end up as \"&entity123;\" in the handler.\n  const char *const entity_start = \"&amp;\";\n  const char *const entity_end = \";\";\n\n  STRING_POOL *const pool = &(parser->m_dtd->entityValuePool);\n  if (! poolAppendString(pool, entity_start)\n      || ! poolAppendString(pool, entity->name)\n      || ! poolAppendString(pool, entity_end)) {\n    poolDiscard(pool);\n    return XML_ERROR_NO_MEMORY;\n  }\n\n  entity->textPtr = poolStart(pool);\n  entity->textLen = (int)(poolLength(pool));\n  poolFinish(pool);\n\n  return XML_ERROR_NONE;\n}\n\n#endif /* XML_GE == 0 */\n\nstatic void FASTCALL\nnormalizeLines(XML_Char *s) {\n  XML_Char *p;\n  for (;; s++) {\n    if (*s == XML_T('\\0'))\n      return;\n    if (*s == 0xD)\n      break;\n  }\n  p = s;\n  do {\n    if (*s == 0xD) {\n      *p++ = 0xA;\n      if (*++s == 0xA)\n        s++;\n    } else\n      *p++ = *s++;\n  } while (*s);\n  *p = XML_T('\\0');\n}\n\nstatic int\nreportProcessingInstruction(XML_Parser parser, const ENCODING *enc,\n                            const char *start, const char *end) {\n  const XML_Char *target;\n  XML_Char *data;\n  const char *tem;\n  if (! parser->m_processingInstructionHandler) {\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, start, end);\n    return 1;\n  }\n  start += enc->minBytesPerChar * 2;\n  tem = start + XmlNameLength(enc, start);\n  target = poolStoreString(&parser->m_tempPool, enc, start, tem);\n  if (! target)\n    return 0;\n  poolFinish(&parser->m_tempPool);\n  data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),\n                         end - enc->minBytesPerChar * 2);\n  if (! data)\n    return 0;\n  normalizeLines(data);\n  parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);\n  poolClear(&parser->m_tempPool);\n  return 1;\n}\n\nstatic int\nreportComment(XML_Parser parser, const ENCODING *enc, const char *start,\n              const char *end) {\n  XML_Char *data;\n  if (! parser->m_commentHandler) {\n    if (parser->m_defaultHandler)\n      reportDefault(parser, enc, start, end);\n    return 1;\n  }\n  data = poolStoreString(&parser->m_tempPool, enc,\n                         start + enc->minBytesPerChar * 4,\n                         end - enc->minBytesPerChar * 3);\n  if (! data)\n    return 0;\n  normalizeLines(data);\n  parser->m_commentHandler(parser->m_handlerArg, data);\n  poolClear(&parser->m_tempPool);\n  return 1;\n}\n\nstatic void\nreportDefault(XML_Parser parser, const ENCODING *enc, const char *s,\n              const char *end) {\n  if (MUST_CONVERT(enc, s)) {\n    enum XML_Convert_Result convert_res;\n    const char **eventPP;\n    const char **eventEndPP;\n    if (enc == parser->m_encoding) {\n      eventPP = &parser->m_eventPtr;\n      eventEndPP = &parser->m_eventEndPtr;\n    } else {\n      /* To get here, two things must be true; the parser must be\n       * using a character encoding that is not the same as the\n       * encoding passed in, and the encoding passed in must need\n       * conversion to the internal format (UTF-8 unless XML_UNICODE\n       * is defined).  The only occasions on which the encoding passed\n       * in is not the same as the parser's encoding are when it is\n       * the internal encoding (e.g. a previously defined parameter\n       * entity, already converted to internal format).  This by\n       * definition doesn't need conversion, so the whole branch never\n       * gets executed.\n       *\n       * For safety's sake we don't delete these lines and merely\n       * exclude them from coverage statistics.\n       *\n       * LCOV_EXCL_START\n       */\n      eventPP = &(parser->m_openInternalEntities->internalEventPtr);\n      eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);\n      /* LCOV_EXCL_STOP */\n    }\n    do {\n      ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;\n      convert_res\n          = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);\n      *eventEndPP = s;\n      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,\n                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));\n      *eventPP = s;\n    } while ((convert_res != XML_CONVERT_COMPLETED)\n             && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));\n  } else\n    parser->m_defaultHandler(\n        parser->m_handlerArg, (const XML_Char *)s,\n        (int)((const XML_Char *)end - (const XML_Char *)s));\n}\n\nstatic int\ndefineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n                XML_Bool isId, const XML_Char *value, XML_Parser parser) {\n  DEFAULT_ATTRIBUTE *att;\n  if (value || isId) {\n    /* The handling of default attributes gets messed up if we have\n       a default which duplicates a non-default. */\n    int i;\n    for (i = 0; i < type->nDefaultAtts; i++)\n      if (attId == type->defaultAtts[i].id)\n        return 1;\n    if (isId && ! type->idAtt && ! attId->xmlns)\n      type->idAtt = attId;\n  }\n  if (type->nDefaultAtts == type->allocDefaultAtts) {\n    if (type->allocDefaultAtts == 0) {\n      type->allocDefaultAtts = 8;\n      type->defaultAtts\n          = MALLOC(parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));\n      if (! type->defaultAtts) {\n        type->allocDefaultAtts = 0;\n        return 0;\n      }\n    } else {\n      DEFAULT_ATTRIBUTE *temp;\n\n      /* Detect and prevent integer overflow */\n      if (type->allocDefaultAtts > INT_MAX / 2) {\n        return 0;\n      }\n\n      int count = type->allocDefaultAtts * 2;\n\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((unsigned)count > SIZE_MAX / sizeof(DEFAULT_ATTRIBUTE)) {\n        return 0;\n      }\n#endif\n\n      temp = REALLOC(parser, type->defaultAtts,\n                     (count * sizeof(DEFAULT_ATTRIBUTE)));\n      if (temp == NULL)\n        return 0;\n      type->allocDefaultAtts = count;\n      type->defaultAtts = temp;\n    }\n  }\n  att = type->defaultAtts + type->nDefaultAtts;\n  att->id = attId;\n  att->value = value;\n  att->isCdata = isCdata;\n  if (! isCdata)\n    attId->maybeTokenized = XML_TRUE;\n  type->nDefaultAtts += 1;\n  return 1;\n}\n\nstatic int\nsetElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *name;\n  for (name = elementType->name; *name; name++) {\n    if (*name == XML_T(ASCII_COLON)) {\n      PREFIX *prefix;\n      const XML_Char *s;\n      for (s = elementType->name; s != name; s++) {\n        if (! poolAppendChar(&dtd->pool, *s))\n          return 0;\n      }\n      if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n        return 0;\n      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),\n                                sizeof(PREFIX));\n      if (! prefix)\n        return 0;\n      if (prefix->name == poolStart(&dtd->pool))\n        poolFinish(&dtd->pool);\n      else\n        poolDiscard(&dtd->pool);\n      elementType->prefix = prefix;\n      break;\n    }\n  }\n  return 1;\n}\n\nstatic ATTRIBUTE_ID *\ngetAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,\n               const char *end) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  ATTRIBUTE_ID *id;\n  const XML_Char *name;\n  if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n    return NULL;\n  name = poolStoreString(&dtd->pool, enc, start, end);\n  if (! name)\n    return NULL;\n  /* skip quotation mark - its storage will be reused (like in name[-1]) */\n  ++name;\n  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,\n                              sizeof(ATTRIBUTE_ID));\n  if (! id)\n    return NULL;\n  if (id->name != name)\n    poolDiscard(&dtd->pool);\n  else {\n    poolFinish(&dtd->pool);\n    if (! parser->m_ns)\n      ;\n    else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)\n             && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)\n             && name[4] == XML_T(ASCII_s)\n             && (name[5] == XML_T('\\0') || name[5] == XML_T(ASCII_COLON))) {\n      if (name[5] == XML_T('\\0'))\n        id->prefix = &dtd->defaultPrefix;\n      else\n        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,\n                                      sizeof(PREFIX));\n      id->xmlns = XML_TRUE;\n    } else {\n      int i;\n      for (i = 0; name[i]; i++) {\n        /* attributes without prefix are *not* in the default namespace */\n        if (name[i] == XML_T(ASCII_COLON)) {\n          int j;\n          for (j = 0; j < i; j++) {\n            if (! poolAppendChar(&dtd->pool, name[j]))\n              return NULL;\n          }\n          if (! poolAppendChar(&dtd->pool, XML_T('\\0')))\n            return NULL;\n          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,\n                                        poolStart(&dtd->pool), sizeof(PREFIX));\n          if (! id->prefix)\n            return NULL;\n          if (id->prefix->name == poolStart(&dtd->pool))\n            poolFinish(&dtd->pool);\n          else\n            poolDiscard(&dtd->pool);\n          break;\n        }\n      }\n    }\n  }\n  return id;\n}\n\n#define CONTEXT_SEP XML_T(ASCII_FF)\n\nstatic const XML_Char *\ngetContext(XML_Parser parser) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  HASH_TABLE_ITER iter;\n  XML_Bool needSep = XML_FALSE;\n\n  if (dtd->defaultPrefix.binding) {\n    int i;\n    int len;\n    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))\n      return NULL;\n    len = dtd->defaultPrefix.binding->uriLen;\n    if (parser->m_namespaceSeparator)\n      len--;\n    for (i = 0; i < len; i++) {\n      if (! poolAppendChar(&parser->m_tempPool,\n                           dtd->defaultPrefix.binding->uri[i])) {\n        /* Because of memory caching, I don't believe this line can be\n         * executed.\n         *\n         * This is part of a loop copying the default prefix binding\n         * URI into the parser's temporary string pool.  Previously,\n         * that URI was copied into the same string pool, with a\n         * terminating NUL character, as part of setContext().  When\n         * the pool was cleared, that leaves a block definitely big\n         * enough to hold the URI on the free block list of the pool.\n         * The URI copy in getContext() therefore cannot run out of\n         * memory.\n         *\n         * If the pool is used between the setContext() and\n         * getContext() calls, the worst it can do is leave a bigger\n         * block on the front of the free list.  Given that this is\n         * all somewhat inobvious and program logic can be changed, we\n         * don't delete the line but we do exclude it from the test\n         * coverage statistics.\n         */\n        return NULL; /* LCOV_EXCL_LINE */\n      }\n    }\n    needSep = XML_TRUE;\n  }\n\n  hashTableIterInit(&iter, &(dtd->prefixes));\n  for (;;) {\n    int i;\n    int len;\n    const XML_Char *s;\n    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);\n    if (! prefix)\n      break;\n    if (! prefix->binding) {\n      /* This test appears to be (justifiable) paranoia.  There does\n       * not seem to be a way of injecting a prefix without a binding\n       * that doesn't get errored long before this function is called.\n       * The test should remain for safety's sake, so we instead\n       * exclude the following line from the coverage statistics.\n       */\n      continue; /* LCOV_EXCL_LINE */\n    }\n    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))\n      return NULL;\n    for (s = prefix->name; *s; s++)\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return NULL;\n    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))\n      return NULL;\n    len = prefix->binding->uriLen;\n    if (parser->m_namespaceSeparator)\n      len--;\n    for (i = 0; i < len; i++)\n      if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))\n        return NULL;\n    needSep = XML_TRUE;\n  }\n\n  hashTableIterInit(&iter, &(dtd->generalEntities));\n  for (;;) {\n    const XML_Char *s;\n    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (! e->open)\n      continue;\n    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))\n      return NULL;\n    for (s = e->name; *s; s++)\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return 0;\n    needSep = XML_TRUE;\n  }\n\n  if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n    return NULL;\n  return parser->m_tempPool.start;\n}\n\nstatic XML_Bool\nsetContext(XML_Parser parser, const XML_Char *context) {\n  if (context == NULL) {\n    return XML_FALSE;\n  }\n\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *s = context;\n\n  while (*context != XML_T('\\0')) {\n    if (*s == CONTEXT_SEP || *s == XML_T('\\0')) {\n      ENTITY *e;\n      if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n        return XML_FALSE;\n      e = (ENTITY *)lookup(parser, &dtd->generalEntities,\n                           poolStart(&parser->m_tempPool), 0);\n      if (e)\n        e->open = XML_TRUE;\n      if (*s != XML_T('\\0'))\n        s++;\n      context = s;\n      poolDiscard(&parser->m_tempPool);\n    } else if (*s == XML_T(ASCII_EQUALS)) {\n      PREFIX *prefix;\n      if (poolLength(&parser->m_tempPool) == 0)\n        prefix = &dtd->defaultPrefix;\n      else {\n        if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n          return XML_FALSE;\n        const XML_Char *const prefixName = poolCopyStringNoFinish(\n            &dtd->pool, poolStart(&parser->m_tempPool));\n        if (! prefixName) {\n          return XML_FALSE;\n        }\n\n        prefix = (PREFIX *)lookup(parser, &dtd->prefixes, prefixName,\n                                  sizeof(PREFIX));\n\n        const bool prefixNameUsed = prefix && prefix->name == prefixName;\n        if (prefixNameUsed)\n          poolFinish(&dtd->pool);\n        else\n          poolDiscard(&dtd->pool);\n\n        if (! prefix)\n          return XML_FALSE;\n\n        poolDiscard(&parser->m_tempPool);\n      }\n      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\\0');\n           context++)\n        if (! poolAppendChar(&parser->m_tempPool, *context))\n          return XML_FALSE;\n      if (! poolAppendChar(&parser->m_tempPool, XML_T('\\0')))\n        return XML_FALSE;\n      if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),\n                     &parser->m_inheritedBindings)\n          != XML_ERROR_NONE)\n        return XML_FALSE;\n      poolDiscard(&parser->m_tempPool);\n      if (*context != XML_T('\\0'))\n        ++context;\n      s = context;\n    } else {\n      if (! poolAppendChar(&parser->m_tempPool, *s))\n        return XML_FALSE;\n      s++;\n    }\n  }\n  return XML_TRUE;\n}\n\nstatic void FASTCALL\nnormalizePublicId(XML_Char *publicId) {\n  XML_Char *p = publicId;\n  XML_Char *s;\n  for (s = publicId; *s; s++) {\n    switch (*s) {\n    case 0x20:\n    case 0xD:\n    case 0xA:\n      if (p != publicId && p[-1] != 0x20)\n        *p++ = 0x20;\n      break;\n    default:\n      *p++ = *s;\n    }\n  }\n  if (p != publicId && p[-1] == 0x20)\n    --p;\n  *p = XML_T('\\0');\n}\n\nstatic DTD *\ndtdCreate(XML_Parser parser) {\n  DTD *p = MALLOC(parser, sizeof(DTD));\n  if (p == NULL)\n    return p;\n  poolInit(&(p->pool), parser);\n  poolInit(&(p->entityValuePool), parser);\n  hashTableInit(&(p->generalEntities), parser);\n  hashTableInit(&(p->elementTypes), parser);\n  hashTableInit(&(p->attributeIds), parser);\n  hashTableInit(&(p->prefixes), parser);\n#ifdef XML_DTD\n  p->paramEntityRead = XML_FALSE;\n  hashTableInit(&(p->paramEntities), parser);\n#endif /* XML_DTD */\n  p->defaultPrefix.name = NULL;\n  p->defaultPrefix.binding = NULL;\n\n  p->in_eldecl = XML_FALSE;\n  p->scaffIndex = NULL;\n  p->scaffold = NULL;\n  p->scaffLevel = 0;\n  p->scaffSize = 0;\n  p->scaffCount = 0;\n  p->contentStringLen = 0;\n\n  p->keepProcessing = XML_TRUE;\n  p->hasParamEntityRefs = XML_FALSE;\n  p->standalone = XML_FALSE;\n  return p;\n}\n\nstatic void\ndtdReset(DTD *p, XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n  hashTableIterInit(&iter, &(p->elementTypes));\n  for (;;) {\n    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (e->allocDefaultAtts != 0)\n      FREE(parser, e->defaultAtts);\n  }\n  hashTableClear(&(p->generalEntities));\n#ifdef XML_DTD\n  p->paramEntityRead = XML_FALSE;\n  hashTableClear(&(p->paramEntities));\n#endif /* XML_DTD */\n  hashTableClear(&(p->elementTypes));\n  hashTableClear(&(p->attributeIds));\n  hashTableClear(&(p->prefixes));\n  poolClear(&(p->pool));\n  poolClear(&(p->entityValuePool));\n  p->defaultPrefix.name = NULL;\n  p->defaultPrefix.binding = NULL;\n\n  p->in_eldecl = XML_FALSE;\n\n  FREE(parser, p->scaffIndex);\n  p->scaffIndex = NULL;\n  FREE(parser, p->scaffold);\n  p->scaffold = NULL;\n\n  p->scaffLevel = 0;\n  p->scaffSize = 0;\n  p->scaffCount = 0;\n  p->contentStringLen = 0;\n\n  p->keepProcessing = XML_TRUE;\n  p->hasParamEntityRefs = XML_FALSE;\n  p->standalone = XML_FALSE;\n}\n\nstatic void\ndtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n  hashTableIterInit(&iter, &(p->elementTypes));\n  for (;;) {\n    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! e)\n      break;\n    if (e->allocDefaultAtts != 0)\n      FREE(parser, e->defaultAtts);\n  }\n  hashTableDestroy(&(p->generalEntities));\n#ifdef XML_DTD\n  hashTableDestroy(&(p->paramEntities));\n#endif /* XML_DTD */\n  hashTableDestroy(&(p->elementTypes));\n  hashTableDestroy(&(p->attributeIds));\n  hashTableDestroy(&(p->prefixes));\n  poolDestroy(&(p->pool));\n  poolDestroy(&(p->entityValuePool));\n  if (isDocEntity) {\n    FREE(parser, p->scaffIndex);\n    FREE(parser, p->scaffold);\n  }\n  FREE(parser, p);\n}\n\n/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.\n   The new DTD has already been initialized.\n*/\nstatic int\ndtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n        XML_Parser parser) {\n  HASH_TABLE_ITER iter;\n\n  /* Copy the prefix table. */\n\n  hashTableIterInit(&iter, &(oldDtd->prefixes));\n  for (;;) {\n    const XML_Char *name;\n    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);\n    if (! oldP)\n      break;\n    name = poolCopyString(&(newDtd->pool), oldP->name);\n    if (! name)\n      return 0;\n    if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))\n      return 0;\n  }\n\n  hashTableIterInit(&iter, &(oldDtd->attributeIds));\n\n  /* Copy the attribute id table. */\n\n  for (;;) {\n    ATTRIBUTE_ID *newA;\n    const XML_Char *name;\n    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);\n\n    if (! oldA)\n      break;\n    /* Remember to allocate the scratch byte before the name. */\n    if (! poolAppendChar(&(newDtd->pool), XML_T('\\0')))\n      return 0;\n    name = poolCopyString(&(newDtd->pool), oldA->name);\n    if (! name)\n      return 0;\n    ++name;\n    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,\n                                  sizeof(ATTRIBUTE_ID));\n    if (! newA)\n      return 0;\n    newA->maybeTokenized = oldA->maybeTokenized;\n    if (oldA->prefix) {\n      newA->xmlns = oldA->xmlns;\n      if (oldA->prefix == &oldDtd->defaultPrefix)\n        newA->prefix = &newDtd->defaultPrefix;\n      else\n        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                        oldA->prefix->name, 0);\n    }\n  }\n\n  /* Copy the element type table. */\n\n  hashTableIterInit(&iter, &(oldDtd->elementTypes));\n\n  for (;;) {\n    int i;\n    ELEMENT_TYPE *newE;\n    const XML_Char *name;\n    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n    if (! oldE)\n      break;\n    name = poolCopyString(&(newDtd->pool), oldE->name);\n    if (! name)\n      return 0;\n    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,\n                                  sizeof(ELEMENT_TYPE));\n    if (! newE)\n      return 0;\n    if (oldE->nDefaultAtts) {\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if ((size_t)oldE->nDefaultAtts > SIZE_MAX / sizeof(DEFAULT_ATTRIBUTE)) {\n        return 0;\n      }\n#endif\n      newE->defaultAtts\n          = MALLOC(parser, oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));\n      if (! newE->defaultAtts) {\n        return 0;\n      }\n    }\n    if (oldE->idAtt)\n      newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),\n                                           oldE->idAtt->name, 0);\n    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;\n    if (oldE->prefix)\n      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                      oldE->prefix->name, 0);\n    for (i = 0; i < newE->nDefaultAtts; i++) {\n      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(\n          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);\n      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;\n      if (oldE->defaultAtts[i].value) {\n        newE->defaultAtts[i].value\n            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);\n        if (! newE->defaultAtts[i].value)\n          return 0;\n      } else\n        newE->defaultAtts[i].value = NULL;\n    }\n  }\n\n  /* Copy the entity tables. */\n  if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),\n                        &(oldDtd->generalEntities)))\n    return 0;\n\n#ifdef XML_DTD\n  if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),\n                        &(oldDtd->paramEntities)))\n    return 0;\n  newDtd->paramEntityRead = oldDtd->paramEntityRead;\n#endif /* XML_DTD */\n\n  newDtd->keepProcessing = oldDtd->keepProcessing;\n  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;\n  newDtd->standalone = oldDtd->standalone;\n\n  /* Don't want deep copying for scaffolding */\n  newDtd->in_eldecl = oldDtd->in_eldecl;\n  newDtd->scaffold = oldDtd->scaffold;\n  newDtd->contentStringLen = oldDtd->contentStringLen;\n  newDtd->scaffSize = oldDtd->scaffSize;\n  newDtd->scaffLevel = oldDtd->scaffLevel;\n  newDtd->scaffIndex = oldDtd->scaffIndex;\n\n  return 1;\n} /* End dtdCopy */\n\nstatic int\ncopyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,\n                STRING_POOL *newPool, const HASH_TABLE *oldTable) {\n  HASH_TABLE_ITER iter;\n  const XML_Char *cachedOldBase = NULL;\n  const XML_Char *cachedNewBase = NULL;\n\n  hashTableIterInit(&iter, oldTable);\n\n  for (;;) {\n    ENTITY *newE;\n    const XML_Char *name;\n    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);\n    if (! oldE)\n      break;\n    name = poolCopyString(newPool, oldE->name);\n    if (! name)\n      return 0;\n    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));\n    if (! newE)\n      return 0;\n    if (oldE->systemId) {\n      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);\n      if (! tem)\n        return 0;\n      newE->systemId = tem;\n      if (oldE->base) {\n        if (oldE->base == cachedOldBase)\n          newE->base = cachedNewBase;\n        else {\n          cachedOldBase = oldE->base;\n          tem = poolCopyString(newPool, cachedOldBase);\n          if (! tem)\n            return 0;\n          cachedNewBase = newE->base = tem;\n        }\n      }\n      if (oldE->publicId) {\n        tem = poolCopyString(newPool, oldE->publicId);\n        if (! tem)\n          return 0;\n        newE->publicId = tem;\n      }\n    } else {\n      const XML_Char *tem\n          = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);\n      if (! tem)\n        return 0;\n      newE->textPtr = tem;\n      newE->textLen = oldE->textLen;\n    }\n    if (oldE->notation) {\n      const XML_Char *tem = poolCopyString(newPool, oldE->notation);\n      if (! tem)\n        return 0;\n      newE->notation = tem;\n    }\n    newE->is_param = oldE->is_param;\n    newE->is_internal = oldE->is_internal;\n  }\n  return 1;\n}\n\n#define INIT_POWER 6\n\nstatic XML_Bool FASTCALL\nkeyeq(KEY s1, KEY s2) {\n  for (; *s1 == *s2; s1++, s2++)\n    if (*s1 == 0)\n      return XML_TRUE;\n  return XML_FALSE;\n}\n\nstatic size_t\nkeylen(KEY s) {\n  size_t len = 0;\n  for (; *s; s++, len++)\n    ;\n  return len;\n}\n\nstatic void\ncopy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {\n  const XML_Parser rootParser = getRootParserOf(parser, NULL);\n  assert(! rootParser->m_parentParser);\n\n  *key = rootParser->m_hash_secret_salt_128;\n}\n\nstatic unsigned long FASTCALL\nhash(XML_Parser parser, KEY s) {\n  struct siphash state;\n  struct sipkey key;\n  (void)sip24_valid;\n  copy_salt_to_sipkey(parser, &key);\n  sip24_init(&state, &key);\n  sip24_update(&state, s, keylen(s) * sizeof(XML_Char));\n  return (unsigned long)sip24_final(&state);\n}\n\nstatic NAMED *\nlookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {\n  size_t i;\n  if (table->size == 0) {\n    size_t tsize;\n    if (! createSize)\n      return NULL;\n    table->power = INIT_POWER;\n    /* table->size is a power of 2 */\n    table->size = (size_t)1 << INIT_POWER;\n    tsize = table->size * sizeof(NAMED *);\n    table->v = MALLOC(table->parser, tsize);\n    if (! table->v) {\n      table->size = 0;\n      return NULL;\n    }\n    memset(table->v, 0, tsize);\n    i = hash(parser, name) & ((unsigned long)table->size - 1);\n  } else {\n    unsigned long h = hash(parser, name);\n    unsigned long mask = (unsigned long)table->size - 1;\n    unsigned char step = 0;\n    i = h & mask;\n    while (table->v[i]) {\n      if (keyeq(name, table->v[i]->name))\n        return table->v[i];\n      if (! step)\n        step = PROBE_STEP(h, mask, table->power);\n      i < step ? (i += table->size - step) : (i -= step);\n    }\n    if (! createSize)\n      return NULL;\n\n    /* check for overflow (table is half full) */\n    if (table->used >> (table->power - 1)) {\n      unsigned char newPower = table->power + 1;\n\n      /* Detect and prevent invalid shift */\n      if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {\n        return NULL;\n      }\n\n      size_t newSize = (size_t)1 << newPower;\n      unsigned long newMask = (unsigned long)newSize - 1;\n\n      /* Detect and prevent integer overflow */\n      if (newSize > SIZE_MAX / sizeof(NAMED *)) {\n        return NULL;\n      }\n\n      size_t tsize = newSize * sizeof(NAMED *);\n      NAMED **newV = MALLOC(table->parser, tsize);\n      if (! newV)\n        return NULL;\n      memset(newV, 0, tsize);\n      for (i = 0; i < table->size; i++)\n        if (table->v[i]) {\n          unsigned long newHash = hash(parser, table->v[i]->name);\n          size_t j = newHash & newMask;\n          step = 0;\n          while (newV[j]) {\n            if (! step)\n              step = PROBE_STEP(newHash, newMask, newPower);\n            j < step ? (j += newSize - step) : (j -= step);\n          }\n          newV[j] = table->v[i];\n        }\n      FREE(table->parser, table->v);\n      table->v = newV;\n      table->power = newPower;\n      table->size = newSize;\n      i = h & newMask;\n      step = 0;\n      while (table->v[i]) {\n        if (! step)\n          step = PROBE_STEP(h, newMask, newPower);\n        i < step ? (i += newSize - step) : (i -= step);\n      }\n    }\n  }\n  table->v[i] = MALLOC(table->parser, createSize);\n  if (! table->v[i])\n    return NULL;\n  memset(table->v[i], 0, createSize);\n  table->v[i]->name = name;\n  (table->used)++;\n  return table->v[i];\n}\n\nstatic void FASTCALL\nhashTableClear(HASH_TABLE *table) {\n  size_t i;\n  for (i = 0; i < table->size; i++) {\n    FREE(table->parser, table->v[i]);\n    table->v[i] = NULL;\n  }\n  table->used = 0;\n}\n\nstatic void FASTCALL\nhashTableDestroy(HASH_TABLE *table) {\n  size_t i;\n  for (i = 0; i < table->size; i++)\n    FREE(table->parser, table->v[i]);\n  FREE(table->parser, table->v);\n}\n\nstatic void FASTCALL\nhashTableInit(HASH_TABLE *p, XML_Parser parser) {\n  p->power = 0;\n  p->size = 0;\n  p->used = 0;\n  p->v = NULL;\n  p->parser = parser;\n}\n\nstatic void FASTCALL\nhashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {\n  iter->p = table->v;\n  iter->end = iter->p ? iter->p + table->size : NULL;\n}\n\nstatic NAMED *FASTCALL\nhashTableIterNext(HASH_TABLE_ITER *iter) {\n  while (iter->p != iter->end) {\n    NAMED *tem = *(iter->p)++;\n    if (tem)\n      return tem;\n  }\n  return NULL;\n}\n\nstatic void FASTCALL\npoolInit(STRING_POOL *pool, XML_Parser parser) {\n  pool->blocks = NULL;\n  pool->freeBlocks = NULL;\n  pool->start = NULL;\n  pool->ptr = NULL;\n  pool->end = NULL;\n  pool->parser = parser;\n}\n\nstatic void FASTCALL\npoolClear(STRING_POOL *pool) {\n  if (! pool->freeBlocks)\n    pool->freeBlocks = pool->blocks;\n  else {\n    BLOCK *p = pool->blocks;\n    while (p) {\n      BLOCK *tem = p->next;\n      p->next = pool->freeBlocks;\n      pool->freeBlocks = p;\n      p = tem;\n    }\n  }\n  pool->blocks = NULL;\n  pool->start = NULL;\n  pool->ptr = NULL;\n  pool->end = NULL;\n}\n\nstatic void FASTCALL\npoolDestroy(STRING_POOL *pool) {\n  BLOCK *p = pool->blocks;\n  while (p) {\n    BLOCK *tem = p->next;\n    FREE(pool->parser, p);\n    p = tem;\n  }\n  p = pool->freeBlocks;\n  while (p) {\n    BLOCK *tem = p->next;\n    FREE(pool->parser, p);\n    p = tem;\n  }\n}\n\nstatic XML_Char *\npoolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,\n           const char *end) {\n  if (! pool->ptr && ! poolGrow(pool))\n    return NULL;\n  for (;;) {\n    const enum XML_Convert_Result convert_res = XmlConvert(\n        enc, &ptr, end, (ICHAR **)&(pool->ptr), (const ICHAR *)pool->end);\n    if ((convert_res == XML_CONVERT_COMPLETED)\n        || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))\n      break;\n    if (! poolGrow(pool))\n      return NULL;\n  }\n  return pool->start;\n}\n\nstatic const XML_Char *FASTCALL\npoolCopyString(STRING_POOL *pool, const XML_Char *s) {\n  do {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n  } while (*s++);\n  s = pool->start;\n  poolFinish(pool);\n  return s;\n}\n\n// A version of `poolCopyString` that does not call `poolFinish`\n// and reverts any partial advancement upon failure.\nstatic const XML_Char *FASTCALL\npoolCopyStringNoFinish(STRING_POOL *pool, const XML_Char *s) {\n  const XML_Char *const original = s;\n  do {\n    if (! poolAppendChar(pool, *s)) {\n      // Revert any previously successful advancement\n      const ptrdiff_t advancedBy = s - original;\n      if (advancedBy > 0)\n        pool->ptr -= advancedBy;\n      return NULL;\n    }\n  } while (*s++);\n  return pool->start;\n}\n\nstatic const XML_Char *\npoolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {\n  if (! pool->ptr && ! poolGrow(pool)) {\n    /* The following line is unreachable given the current usage of\n     * poolCopyStringN().  Currently it is called from exactly one\n     * place to copy the text of a simple general entity.  By that\n     * point, the name of the entity is already stored in the pool, so\n     * pool->ptr cannot be NULL.\n     *\n     * If poolCopyStringN() is used elsewhere as it well might be,\n     * this line may well become executable again.  Regardless, this\n     * sort of check shouldn't be removed lightly, so we just exclude\n     * it from the coverage statistics.\n     */\n    return NULL; /* LCOV_EXCL_LINE */\n  }\n  for (; n > 0; --n, s++) {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n  }\n  s = pool->start;\n  poolFinish(pool);\n  return s;\n}\n\nstatic const XML_Char *FASTCALL\npoolAppendString(STRING_POOL *pool, const XML_Char *s) {\n  while (*s) {\n    if (! poolAppendChar(pool, *s))\n      return NULL;\n    s++;\n  }\n  return pool->start;\n}\n\nstatic XML_Char *\npoolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,\n                const char *end) {\n  if (! poolAppend(pool, enc, ptr, end))\n    return NULL;\n  if (pool->ptr == pool->end && ! poolGrow(pool))\n    return NULL;\n  *(pool->ptr)++ = 0;\n  return pool->start;\n}\n\nstatic size_t\npoolBytesToAllocateFor(int blockSize) {\n  /* Unprotected math would be:\n  ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);\n  **\n  ** Detect overflow, avoiding _signed_ overflow undefined behavior\n  ** For a + b * c we check b * c in isolation first, so that addition of a\n  ** on top has no chance of making us accept a small non-negative number\n  */\n  const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */\n\n  if (blockSize <= 0)\n    return 0;\n\n  if (blockSize > (int)(INT_MAX / stretch))\n    return 0;\n\n  {\n    const int stretchedBlockSize = blockSize * (int)stretch;\n    const int bytesToAllocate\n        = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);\n    if (bytesToAllocate < 0)\n      return 0;\n\n    return (size_t)bytesToAllocate;\n  }\n}\n\nstatic XML_Bool FASTCALL\npoolGrow(STRING_POOL *pool) {\n  if (pool->freeBlocks) {\n    if (pool->start == NULL) {\n      pool->blocks = pool->freeBlocks;\n      pool->freeBlocks = pool->freeBlocks->next;\n      pool->blocks->next = NULL;\n      pool->start = pool->blocks->s;\n      pool->end = pool->start + pool->blocks->size;\n      pool->ptr = pool->start;\n      return XML_TRUE;\n    }\n    if (pool->end - pool->start < pool->freeBlocks->size) {\n      BLOCK *tem = pool->freeBlocks->next;\n      pool->freeBlocks->next = pool->blocks;\n      pool->blocks = pool->freeBlocks;\n      pool->freeBlocks = tem;\n      memcpy(pool->blocks->s, pool->start,\n             (pool->end - pool->start) * sizeof(XML_Char));\n      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);\n      pool->start = pool->blocks->s;\n      pool->end = pool->start + pool->blocks->size;\n      return XML_TRUE;\n    }\n  }\n  if (pool->blocks && pool->start == pool->blocks->s) {\n    BLOCK *temp;\n    int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);\n    size_t bytesToAllocate;\n\n    /* NOTE: Needs to be calculated prior to calling `realloc`\n             to avoid dangling pointers: */\n    const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;\n\n    if (blockSize < 0) {\n      /* This condition traps a situation where either more than\n       * INT_MAX/2 bytes have already been allocated.  This isn't\n       * readily testable, since it is unlikely that an average\n       * machine will have that much memory, so we exclude it from the\n       * coverage statistics.\n       */\n      return XML_FALSE; /* LCOV_EXCL_LINE */\n    }\n\n    bytesToAllocate = poolBytesToAllocateFor(blockSize);\n    if (bytesToAllocate == 0)\n      return XML_FALSE;\n\n    temp = REALLOC(pool->parser, pool->blocks, bytesToAllocate);\n    if (temp == NULL)\n      return XML_FALSE;\n    pool->blocks = temp;\n    pool->blocks->size = blockSize;\n    pool->ptr = pool->blocks->s + offsetInsideBlock;\n    pool->start = pool->blocks->s;\n    pool->end = pool->start + blockSize;\n  } else {\n    BLOCK *tem;\n    int blockSize = (int)(pool->end - pool->start);\n    size_t bytesToAllocate;\n\n    if (blockSize < 0) {\n      /* This condition traps a situation where either more than\n       * INT_MAX bytes have already been allocated (which is prevented\n       * by various pieces of program logic, not least this one, never\n       * mind the unlikelihood of actually having that much memory) or\n       * the pool control fields have been corrupted (which could\n       * conceivably happen in an extremely buggy user handler\n       * function).  Either way it isn't readily testable, so we\n       * exclude it from the coverage statistics.\n       */\n      return XML_FALSE; /* LCOV_EXCL_LINE */\n    }\n\n    if (blockSize < INIT_BLOCK_SIZE)\n      blockSize = INIT_BLOCK_SIZE;\n    else {\n      /* Detect overflow, avoiding _signed_ overflow undefined behavior */\n      if ((int)((unsigned)blockSize * 2U) < 0) {\n        return XML_FALSE;\n      }\n      blockSize *= 2;\n    }\n\n    bytesToAllocate = poolBytesToAllocateFor(blockSize);\n    if (bytesToAllocate == 0)\n      return XML_FALSE;\n\n    tem = MALLOC(pool->parser, bytesToAllocate);\n    if (! tem)\n      return XML_FALSE;\n    tem->size = blockSize;\n    tem->next = pool->blocks;\n    pool->blocks = tem;\n    if (pool->ptr != pool->start)\n      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));\n    pool->ptr = tem->s + (pool->ptr - pool->start);\n    pool->start = tem->s;\n    pool->end = tem->s + blockSize;\n  }\n  return XML_TRUE;\n}\n\nstatic int FASTCALL\nnextScaffoldPart(XML_Parser parser) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  CONTENT_SCAFFOLD *me;\n  int next;\n\n  if (! dtd->scaffIndex) {\n    /* Detect and prevent integer overflow.\n     * The preprocessor guard addresses the \"always false\" warning\n     * from -Wtype-limits on platforms where\n     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n    if (parser->m_groupSize > SIZE_MAX / sizeof(int)) {\n      return -1;\n    }\n#endif\n    dtd->scaffIndex = MALLOC(parser, parser->m_groupSize * sizeof(int));\n    if (! dtd->scaffIndex)\n      return -1;\n    dtd->scaffIndex[0] = 0;\n  }\n\n  // Will casting to int be safe further down?\n  if (dtd->scaffCount > INT_MAX) {\n    return -1;\n  }\n\n  if (dtd->scaffCount >= dtd->scaffSize) {\n    CONTENT_SCAFFOLD *temp;\n    if (dtd->scaffold) {\n      /* Detect and prevent integer overflow */\n      if (dtd->scaffSize > UINT_MAX / 2u) {\n        return -1;\n      }\n      /* Detect and prevent integer overflow.\n       * The preprocessor guard addresses the \"always false\" warning\n       * from -Wtype-limits on platforms where\n       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n      if (dtd->scaffSize > SIZE_MAX / 2u / sizeof(CONTENT_SCAFFOLD)) {\n        return -1;\n      }\n#endif\n\n      temp = REALLOC(parser, dtd->scaffold,\n                     dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));\n      if (temp == NULL)\n        return -1;\n      dtd->scaffSize *= 2;\n    } else {\n      temp = MALLOC(parser, INIT_SCAFFOLD_ELEMENTS * sizeof(CONTENT_SCAFFOLD));\n      if (temp == NULL)\n        return -1;\n      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;\n    }\n    dtd->scaffold = temp;\n  }\n  next = (int)dtd->scaffCount++;\n  me = &dtd->scaffold[next];\n  if (dtd->scaffLevel) {\n    CONTENT_SCAFFOLD *parent\n        = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];\n    if (parent->lastchild) {\n      dtd->scaffold[parent->lastchild].nextsib = next;\n    }\n    if (! parent->childcnt)\n      parent->firstchild = next;\n    parent->lastchild = next;\n    parent->childcnt++;\n  }\n  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;\n  return next;\n}\n\nstatic XML_Content *\nbuild_model(XML_Parser parser) {\n  /* Function build_model transforms the existing parser->m_dtd->scaffold\n   * array of CONTENT_SCAFFOLD tree nodes into a new array of\n   * XML_Content tree nodes followed by a gapless list of zero-terminated\n   * strings. */\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  XML_Content *ret;\n  XML_Char *str; /* the current string writing location */\n\n  /* Detect and prevent integer overflow.\n   * The preprocessor guard addresses the \"always false\" warning\n   * from -Wtype-limits on platforms where\n   * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */\n#if UINT_MAX >= SIZE_MAX\n  if (dtd->scaffCount > SIZE_MAX / sizeof(XML_Content)) {\n    return NULL;\n  }\n  if (dtd->contentStringLen > SIZE_MAX / sizeof(XML_Char)) {\n    return NULL;\n  }\n#endif\n  if (dtd->scaffCount * sizeof(XML_Content)\n      > SIZE_MAX - dtd->contentStringLen * sizeof(XML_Char)) {\n    return NULL;\n  }\n\n  const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)\n                            + (dtd->contentStringLen * sizeof(XML_Char)));\n\n  // NOTE: We are avoiding MALLOC(..) here to so that\n  //       applications that are not using XML_FreeContentModel but plain\n  //       free(..) or .free_fcn() to free the content model's memory are safe.\n  ret = parser->m_mem.malloc_fcn(allocsize);\n  if (! ret)\n    return NULL;\n\n  /* What follows is an iterative implementation (of what was previously done\n   * recursively in a dedicated function called \"build_node\".  The old recursive\n   * build_node could be forced into stack exhaustion from input as small as a\n   * few megabyte, and so that was a security issue.  Hence, a function call\n   * stack is avoided now by resolving recursion.)\n   *\n   * The iterative approach works as follows:\n   *\n   * - We have two writing pointers, both walking up the result array; one does\n   *   the work, the other creates \"jobs\" for its colleague to do, and leads\n   *   the way:\n   *\n   *   - The faster one, pointer jobDest, always leads and writes \"what job\n   *     to do\" by the other, once they reach that place in the\n   *     array: leader \"jobDest\" stores the source node array index (relative\n   *     to array dtd->scaffold) in field \"numchildren\".\n   *\n   *   - The slower one, pointer dest, looks at the value stored in the\n   *     \"numchildren\" field (which actually holds a source node array index\n   *     at that time) and puts the real data from dtd->scaffold in.\n   *\n   * - Before the loop starts, jobDest writes source array index 0\n   *   (where the root node is located) so that dest will have something to do\n   *   when it starts operation.\n   *\n   * - Whenever nodes with children are encountered, jobDest appends\n   *   them as new jobs, in order.  As a result, tree node siblings are\n   *   adjacent in the resulting array, for example:\n   *\n   *     [0] root, has two children\n   *       [1] first child of 0, has three children\n   *         [3] first child of 1, does not have children\n   *         [4] second child of 1, does not have children\n   *         [5] third child of 1, does not have children\n   *       [2] second child of 0, does not have children\n   *\n   *   Or (the same data) presented in flat array view:\n   *\n   *     [0] root, has two children\n   *\n   *     [1] first child of 0, has three children\n   *     [2] second child of 0, does not have children\n   *\n   *     [3] first child of 1, does not have children\n   *     [4] second child of 1, does not have children\n   *     [5] third child of 1, does not have children\n   *\n   * - The algorithm repeats until all target array indices have been processed.\n   */\n  XML_Content *dest = ret; /* tree node writing location, moves upwards */\n  XML_Content *const destLimit = &ret[dtd->scaffCount];\n  XML_Content *jobDest = ret; /* next free writing location in target array */\n  str = (XML_Char *)&ret[dtd->scaffCount];\n\n  /* Add the starting job, the root node (index 0) of the source tree  */\n  (jobDest++)->numchildren = 0;\n\n  for (; dest < destLimit; dest++) {\n    /* Retrieve source tree array index from job storage */\n    const int src_node = (int)dest->numchildren;\n\n    /* Convert item */\n    dest->type = dtd->scaffold[src_node].type;\n    dest->quant = dtd->scaffold[src_node].quant;\n    if (dest->type == XML_CTYPE_NAME) {\n      const XML_Char *src;\n      dest->name = str;\n      src = dtd->scaffold[src_node].name;\n      for (;;) {\n        *str++ = *src;\n        if (! *src)\n          break;\n        src++;\n      }\n      dest->numchildren = 0;\n      dest->children = NULL;\n    } else {\n      unsigned int i;\n      int cn;\n      dest->name = NULL;\n      dest->numchildren = dtd->scaffold[src_node].childcnt;\n      dest->children = jobDest;\n\n      /* Append scaffold indices of children to array */\n      for (i = 0, cn = dtd->scaffold[src_node].firstchild;\n           i < dest->numchildren; i++, cn = dtd->scaffold[cn].nextsib)\n        (jobDest++)->numchildren = (unsigned int)cn;\n    }\n  }\n\n  return ret;\n}\n\nstatic ELEMENT_TYPE *\ngetElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,\n               const char *end) {\n  DTD *const dtd = parser->m_dtd; /* save one level of indirection */\n  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);\n  ELEMENT_TYPE *ret;\n\n  if (! name)\n    return NULL;\n  ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,\n                               sizeof(ELEMENT_TYPE));\n  if (! ret)\n    return NULL;\n  if (ret->name != name)\n    poolDiscard(&dtd->pool);\n  else {\n    poolFinish(&dtd->pool);\n    if (! setElementTypePrefix(parser, ret))\n      return NULL;\n  }\n  return ret;\n}\n\nstatic XML_Char *\ncopyString(const XML_Char *s, XML_Parser parser) {\n  size_t charsRequired = 0;\n  XML_Char *result;\n\n  /* First determine how long the string is */\n  while (s[charsRequired] != 0) {\n    charsRequired++;\n  }\n  /* Include the terminator */\n  charsRequired++;\n\n  /* Now allocate space for the copy */\n  result = MALLOC(parser, charsRequired * sizeof(XML_Char));\n  if (result == NULL)\n    return NULL;\n  /* Copy the original into place */\n  memcpy(result, s, charsRequired * sizeof(XML_Char));\n  return result;\n}\n\n#if XML_GE == 1\n\nstatic float\naccountingGetCurrentAmplification(XML_Parser rootParser) {\n  //                                          1.........1.........12 => 22\n  const size_t lenOfShortestInclude = sizeof(\"<!ENTITY a SYSTEM 'b'>\") - 1;\n  const XmlBigCount countBytesOutput\n      = rootParser->m_accounting.countBytesDirect\n        + rootParser->m_accounting.countBytesIndirect;\n  const float amplificationFactor\n      = rootParser->m_accounting.countBytesDirect\n            ? ((float)countBytesOutput\n```", "role": "user"}, {"content": "diff --git a/expat/lib/xmlparse.c b/expat/lib/xmlparse.c\nindex 620d1e4b46..890a9389f1 100644\n--- a/expat/lib/xmlparse.c\n+++ b/expat/lib/xmlparse.c\n@@ -387,6 +387,7 @@ typedef struct {\n   int nDefaultAtts;\n   int allocDefaultAtts;\n   DEFAULT_ATTRIBUTE *defaultAtts;\n+  HASH_TABLE defaultAttsNames;\n } ELEMENT_TYPE;\n \n typedef struct {\n@@ -3769,6 +3770,8 @@ storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,\n                                          sizeof(ELEMENT_TYPE));\n     if (! elementType)\n       return XML_ERROR_NO_MEMORY;\n+    if (! elementType->defaultAttsNames.parser)\n+      hashTableInit(&(elementType->defaultAttsNames), parser);\n     if (parser->m_ns && ! setElementTypePrefix(parser, elementType))\n       return XML_ERROR_NO_MEMORY;\n   }\n@@ -7102,10 +7105,10 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n   if (value || isId) {\n     /* The handling of default attributes gets messed up if we have\n        a default which duplicates a non-default. */\n-    int i;\n-    for (i = 0; i < type->nDefaultAtts; i++)\n-      if (attId == type->defaultAtts[i].id)\n-        return 1;\n+    NAMED *const nameFound\n+        = (NAMED *)lookup(parser, &(type->defaultAttsNames), attId->name, 0);\n+    if (nameFound)\n+      return 1;\n     if (isId && ! type->idAtt && ! attId->xmlns)\n       type->idAtt = attId;\n   }\n@@ -7152,6 +7155,12 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,\n   att->isCdata = isCdata;\n   if (! isCdata)\n     attId->maybeTokenized = XML_TRUE;\n+\n+  NAMED *const nameAddedOrFound = (NAMED *)lookup(\n+      parser, &(type->defaultAttsNames), attId->name, sizeof(NAMED));\n+  if (! nameAddedOrFound)\n+    return 0;\n+\n   type->nDefaultAtts += 1;\n   return 1;\n }\n@@ -7477,6 +7486,7 @@ dtdReset(DTD *p, XML_Parser parser) {\n     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n     if (! e)\n       break;\n+    hashTableDestroy(&(e->defaultAttsNames));\n     if (e->allocDefaultAtts != 0)\n       FREE(parser, e->defaultAtts);\n   }\n@@ -7518,6 +7528,7 @@ dtdDestroy(DTD *p, XML_Bool isDocEntity, XML_Parser parser) {\n     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);\n     if (! e)\n       break;\n+    hashTableDestroy(&(e->defaultAttsNames));\n     if (e->allocDefaultAtts != 0)\n       FREE(parser, e->defaultAtts);\n   }\n@@ -7611,6 +7622,10 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n                                   sizeof(ELEMENT_TYPE));\n     if (! newE)\n       return 0;\n+\n+    if (! newE->defaultAttsNames.parser)\n+      hashTableInit(&(newE->defaultAttsNames), parser);\n+\n     if (oldE->nDefaultAtts) {\n       /* Detect and prevent integer overflow.\n        * The preprocessor guard addresses the \"always false\" warning\n@@ -7635,8 +7650,9 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n       newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),\n                                       oldE->prefix->name, 0);\n     for (i = 0; i < newE->nDefaultAtts; i++) {\n+      const XML_Char *const attributeName = oldE->defaultAtts[i].id->name;\n       newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(\n-          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);\n+          oldParser, &(newDtd->attributeIds), attributeName, 0);\n       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;\n       if (oldE->defaultAtts[i].value) {\n         newE->defaultAtts[i].value\n@@ -7645,6 +7661,12 @@ dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,\n           return 0;\n       } else\n         newE->defaultAtts[i].value = NULL;\n+\n+      NAMED *const nameAddedOrFound = (NAMED *)lookup(\n+          parser, &(newE->defaultAttsNames), attributeName, sizeof(NAMED));\n+      if (! nameAddedOrFound) {\n+        return 0;\n+      }\n     }\n   }\n \n@@ -8391,6 +8413,8 @@ getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,\n                                sizeof(ELEMENT_TYPE));\n   if (! ret)\n     return NULL;\n+  if (! ret->defaultAttsNames.parser)\n+    hashTableInit(&(ret->defaultAttsNames), getRootParserOf(parser, NULL));\n   if (ret->name != name)\n     poolDiscard(&dtd->pool);\n   else {", "role": "assistant"}]}