Home | History | Annotate | Download | only in lib
      1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
      2    See the file COPYING for copying permission.
      3 */
      4 
      5 #include <stddef.h>
      6 #include <string.h>                     /* memset(), memcpy() */
      7 #include <assert.h>
      8 
      9 #define XML_BUILDING_EXPAT 1
     10 
     11 #ifdef COMPILED_FROM_DSP
     12 #include "winconfig.h"
     13 #elif defined(MACOS_CLASSIC)
     14 #include "macconfig.h"
     15 #elif defined(__amigaos4__)
     16 #include "amigaconfig.h"
     17 #elif defined(__WATCOMC__)
     18 #include "watcomconfig.h"
     19 #elif defined(HAVE_EXPAT_CONFIG_H)
     20 #include <expat_config.h>
     21 #endif /* ndef COMPILED_FROM_DSP */
     22 
     23 #include "ascii.h"
     24 #include "expat.h"
     25 
     26 #ifdef XML_UNICODE
     27 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
     28 #define XmlConvert XmlUtf16Convert
     29 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
     30 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
     31 #define XmlEncode XmlUtf16Encode
     32 /* Using pointer subtraction to convert to integer type. */
     33 #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))
     34 typedef unsigned short ICHAR;
     35 #else
     36 #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
     37 #define XmlConvert XmlUtf8Convert
     38 #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
     39 #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
     40 #define XmlEncode XmlUtf8Encode
     41 #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
     42 typedef char ICHAR;
     43 #endif
     44 
     45 
     46 #ifndef XML_NS
     47 
     48 #define XmlInitEncodingNS XmlInitEncoding
     49 #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
     50 #undef XmlGetInternalEncodingNS
     51 #define XmlGetInternalEncodingNS XmlGetInternalEncoding
     52 #define XmlParseXmlDeclNS XmlParseXmlDecl
     53 
     54 #endif
     55 
     56 #ifdef XML_UNICODE
     57 
     58 #ifdef XML_UNICODE_WCHAR_T
     59 #define XML_T(x) (const wchar_t)x
     60 #define XML_L(x) L ## x
     61 #else
     62 #define XML_T(x) (const unsigned short)x
     63 #define XML_L(x) x
     64 #endif
     65 
     66 #else
     67 
     68 #define XML_T(x) x
     69 #define XML_L(x) x
     70 
     71 #endif
     72 
     73 /* Round up n to be a multiple of sz, where sz is a power of 2. */
     74 #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
     75 
     76 /* Handle the case where memmove() doesn't exist. */
     77 #ifndef HAVE_MEMMOVE
     78 #ifdef HAVE_BCOPY
     79 #define memmove(d,s,l) bcopy((s),(d),(l))
     80 #else
     81 #error memmove does not exist on this platform, nor is a substitute available
     82 #endif /* HAVE_BCOPY */
     83 #endif /* HAVE_MEMMOVE */
     84 
     85 #include "internal.h"
     86 #include "xmltok.h"
     87 #include "xmlrole.h"
     88 
     89 typedef const XML_Char *KEY;
     90 
     91 typedef struct {
     92   KEY name;
     93 } NAMED;
     94 
     95 typedef struct {
     96   NAMED **v;
     97   unsigned char power;
     98   size_t size;
     99   size_t used;
    100   const XML_Memory_Handling_Suite *mem;
    101 } HASH_TABLE;
    102 
    103 /* Basic character hash algorithm, taken from Python's string hash:
    104    h = h * 1000003 ^ character, the constant being a prime number.
    105 
    106 */
    107 #ifdef XML_UNICODE
    108 #define CHAR_HASH(h, c) \
    109   (((h) * 0xF4243) ^ (unsigned short)(c))
    110 #else
    111 #define CHAR_HASH(h, c) \
    112   (((h) * 0xF4243) ^ (unsigned char)(c))
    113 #endif
    114 
    115 /* For probing (after a collision) we need a step size relative prime
    116    to the hash table size, which is a power of 2. We use double-hashing,
    117    since we can calculate a second hash value cheaply by taking those bits
    118    of the first hash value that were discarded (masked out) when the table
    119    index was calculated: index = hash & mask, where mask = table->size - 1.
    120    We limit the maximum step size to table->size / 4 (mask >> 2) and make
    121    it odd, since odd numbers are always relative prime to a power of 2.
    122 */
    123 #define SECOND_HASH(hash, mask, power) \
    124   ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))
    125 #define PROBE_STEP(hash, mask, power) \
    126   ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
    127 
    128 typedef struct {
    129   NAMED **p;
    130   NAMED **end;
    131 } HASH_TABLE_ITER;
    132 
    133 #define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
    134 #define INIT_DATA_BUF_SIZE 1024
    135 #define INIT_ATTS_SIZE 16
    136 #define INIT_ATTS_VERSION 0xFFFFFFFF
    137 #define INIT_BLOCK_SIZE 1024
    138 #define INIT_BUFFER_SIZE 1024
    139 
    140 #define EXPAND_SPARE 24
    141 
    142 typedef struct binding {
    143   struct prefix *prefix;
    144   struct binding *nextTagBinding;
    145   struct binding *prevPrefixBinding;
    146   const struct attribute_id *attId;
    147   XML_Char *uri;
    148   int uriLen;
    149   int uriAlloc;
    150 } BINDING;
    151 
    152 typedef struct prefix {
    153   const XML_Char *name;
    154   BINDING *binding;
    155 } PREFIX;
    156 
    157 typedef struct {
    158   const XML_Char *str;
    159   const XML_Char *localPart;
    160   const XML_Char *prefix;
    161   int strLen;
    162   int uriLen;
    163   int prefixLen;
    164 } TAG_NAME;
    165 
    166 /* TAG represents an open element.
    167    The name of the element is stored in both the document and API
    168    encodings.  The memory buffer 'buf' is a separately-allocated
    169    memory area which stores the name.  During the XML_Parse()/
    170    XMLParseBuffer() when the element is open, the memory for the 'raw'
    171    version of the name (in the document encoding) is shared with the
    172    document buffer.  If the element is open across calls to
    173    XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
    174    contain the 'raw' name as well.
    175 
    176    A parser re-uses these structures, maintaining a list of allocated
    177    TAG objects in a free list.
    178 */
    179 typedef struct tag {
    180   struct tag *parent;           /* parent of this element */
    181   const char *rawName;          /* tagName in the original encoding */
    182   int rawNameLength;
    183   TAG_NAME name;                /* tagName in the API encoding */
    184   char *buf;                    /* buffer for name components */
    185   char *bufEnd;                 /* end of the buffer */
    186   BINDING *bindings;
    187 } TAG;
    188 
    189 typedef struct {
    190   const XML_Char *name;
    191   const XML_Char *textPtr;
    192   int textLen;                  /* length in XML_Chars */
    193   int processed;                /* # of processed bytes - when suspended */
    194   const XML_Char *systemId;
    195   const XML_Char *base;
    196   const XML_Char *publicId;
    197   const XML_Char *notation;
    198   XML_Bool open;
    199   XML_Bool is_param;
    200   XML_Bool is_internal; /* true if declared in internal subset outside PE */
    201 } ENTITY;
    202 
    203 typedef struct {
    204   enum XML_Content_Type         type;
    205   enum XML_Content_Quant        quant;
    206   const XML_Char *              name;
    207   int                           firstchild;
    208   int                           lastchild;
    209   int                           childcnt;
    210   int                           nextsib;
    211 } CONTENT_SCAFFOLD;
    212 
    213 #define INIT_SCAFFOLD_ELEMENTS 32
    214 
    215 typedef struct block {
    216   struct block *next;
    217   int size;
    218   XML_Char s[1];
    219 } BLOCK;
    220 
    221 typedef struct {
    222   BLOCK *blocks;
    223   BLOCK *freeBlocks;
    224   const XML_Char *end;
    225   XML_Char *ptr;
    226   XML_Char *start;
    227   const XML_Memory_Handling_Suite *mem;
    228 } STRING_POOL;
    229 
    230 /* The XML_Char before the name is used to determine whether
    231    an attribute has been specified. */
    232 typedef struct attribute_id {
    233   XML_Char *name;
    234   PREFIX *prefix;
    235   XML_Bool maybeTokenized;
    236   XML_Bool xmlns;
    237 } ATTRIBUTE_ID;
    238 
    239 typedef struct {
    240   const ATTRIBUTE_ID *id;
    241   XML_Bool isCdata;
    242   const XML_Char *value;
    243 } DEFAULT_ATTRIBUTE;
    244 
    245 typedef struct {
    246   unsigned long version;
    247   unsigned long hash;
    248   const XML_Char *uriName;
    249 } NS_ATT;
    250 
    251 typedef struct {
    252   const XML_Char *name;
    253   PREFIX *prefix;
    254   const ATTRIBUTE_ID *idAtt;
    255   int nDefaultAtts;
    256   int allocDefaultAtts;
    257   DEFAULT_ATTRIBUTE *defaultAtts;
    258 } ELEMENT_TYPE;
    259 
    260 typedef struct {
    261   HASH_TABLE generalEntities;
    262   HASH_TABLE elementTypes;
    263   HASH_TABLE attributeIds;
    264   HASH_TABLE prefixes;
    265   STRING_POOL pool;
    266   STRING_POOL entityValuePool;
    267   /* false once a parameter entity reference has been skipped */
    268   XML_Bool keepProcessing;
    269   /* true once an internal or external PE reference has been encountered;
    270      this includes the reference to an external subset */
    271   XML_Bool hasParamEntityRefs;
    272   XML_Bool standalone;
    273 #ifdef XML_DTD
    274   /* indicates if external PE has been read */
    275   XML_Bool paramEntityRead;
    276   HASH_TABLE paramEntities;
    277 #endif /* XML_DTD */
    278   PREFIX defaultPrefix;
    279   /* === scaffolding for building content model === */
    280   XML_Bool in_eldecl;
    281   CONTENT_SCAFFOLD *scaffold;
    282   unsigned contentStringLen;
    283   unsigned scaffSize;
    284   unsigned scaffCount;
    285   int scaffLevel;
    286   int *scaffIndex;
    287 } DTD;
    288 
    289 typedef struct open_internal_entity {
    290   const char *internalEventPtr;
    291   const char *internalEventEndPtr;
    292   struct open_internal_entity *next;
    293   ENTITY *entity;
    294   int startTagLevel;
    295   XML_Bool betweenDecl; /* WFC: PE Between Declarations */
    296 } OPEN_INTERNAL_ENTITY;
    297 
    298 typedef enum XML_Error PTRCALL Processor(XML_Parser parser,
    299                                          const char *start,
    300                                          const char *end,
    301                                          const char **endPtr);
    302 
    303 static Processor prologProcessor;
    304 static Processor prologInitProcessor;
    305 static Processor contentProcessor;
    306 static Processor cdataSectionProcessor;
    307 #ifdef XML_DTD
    308 static Processor ignoreSectionProcessor;
    309 static Processor externalParEntProcessor;
    310 static Processor externalParEntInitProcessor;
    311 static Processor entityValueProcessor;
    312 static Processor entityValueInitProcessor;
    313 #endif /* XML_DTD */
    314 static Processor epilogProcessor;
    315 static Processor errorProcessor;
    316 static Processor externalEntityInitProcessor;
    317 static Processor externalEntityInitProcessor2;
    318 static Processor externalEntityInitProcessor3;
    319 static Processor externalEntityContentProcessor;
    320 static Processor internalEntityProcessor;
    321 
    322 static enum XML_Error
    323 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
    324 static enum XML_Error
    325 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
    326                const char *s, const char *next);
    327 static enum XML_Error
    328 initializeEncoding(XML_Parser parser);
    329 static enum XML_Error
    330 doProlog(XML_Parser parser, const ENCODING *enc, const char *s,
    331          const char *end, int tok, const char *next, const char **nextPtr,
    332          XML_Bool haveMore);
    333 static enum XML_Error
    334 processInternalEntity(XML_Parser parser, ENTITY *entity,
    335                       XML_Bool betweenDecl);
    336 static enum XML_Error
    337 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
    338           const char *start, const char *end, const char **endPtr,
    339           XML_Bool haveMore);
    340 static enum XML_Error
    341 doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,
    342                const char *end, const char **nextPtr, XML_Bool haveMore);
    343 #ifdef XML_DTD
    344 static enum XML_Error
    345 doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,
    346                 const char *end, const char **nextPtr, XML_Bool haveMore);
    347 #endif /* XML_DTD */
    348 
    349 static enum XML_Error
    350 storeAtts(XML_Parser parser, const ENCODING *, const char *s,
    351           TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
    352 static enum XML_Error
    353 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
    354            const XML_Char *uri, BINDING **bindingsPtr);
    355 static int
    356 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
    357                 XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
    358 static enum XML_Error
    359 storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
    360                     const char *, const char *, STRING_POOL *);
    361 static enum XML_Error
    362 appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
    363                      const char *, const char *, STRING_POOL *);
    364 static ATTRIBUTE_ID *
    365 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
    366                const char *end);
    367 static int
    368 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
    369 static enum XML_Error
    370 storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,
    371                  const char *end);
    372 static int
    373 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
    374                             const char *start, const char *end);
    375 static int
    376 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
    377               const char *end);
    378 static void
    379 reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,
    380               const char *end);
    381 
    382 static const XML_Char * getContext(XML_Parser parser);
    383 static XML_Bool
    384 setContext(XML_Parser parser, const XML_Char *context);
    385 
    386 static void FASTCALL normalizePublicId(XML_Char *s);
    387 
    388 static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);
    389 /* do not call if parentParser != NULL */
    390 static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
    391 static void
    392 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);
    393 static int
    394 dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);
    395 static int
    396 copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);
    397 
    398 static NAMED *
    399 lookup(HASH_TABLE *table, KEY name, size_t createSize);
    400 static void FASTCALL
    401 hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);
    402 static void FASTCALL hashTableClear(HASH_TABLE *);
    403 static void FASTCALL hashTableDestroy(HASH_TABLE *);
    404 static void FASTCALL
    405 hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
    406 static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
    407 
    408 static void FASTCALL
    409 poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);
    410 static void FASTCALL poolClear(STRING_POOL *);
    411 static void FASTCALL poolDestroy(STRING_POOL *);
    412 static XML_Char *
    413 poolAppend(STRING_POOL *pool, const ENCODING *enc,
    414            const char *ptr, const char *end);
    415 static XML_Char *
    416 poolStoreString(STRING_POOL *pool, const ENCODING *enc,
    417                 const char *ptr, const char *end);
    418 static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
    419 static const XML_Char * FASTCALL
    420 poolCopyString(STRING_POOL *pool, const XML_Char *s);
    421 static const XML_Char *
    422 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
    423 static const XML_Char * FASTCALL
    424 poolAppendString(STRING_POOL *pool, const XML_Char *s);
    425 
    426 static int FASTCALL nextScaffoldPart(XML_Parser parser);
    427 static XML_Content * build_model(XML_Parser parser);
    428 static ELEMENT_TYPE *
    429 getElementType(XML_Parser parser, const ENCODING *enc,
    430                const char *ptr, const char *end);
    431 
    432 static XML_Parser
    433 parserCreate(const XML_Char *encodingName,
    434              const XML_Memory_Handling_Suite *memsuite,
    435              const XML_Char *nameSep,
    436              DTD *dtd);
    437 static void
    438 parserInit(XML_Parser parser, const XML_Char *encodingName);
    439 
    440 #define poolStart(pool) ((pool)->start)
    441 #define poolEnd(pool) ((pool)->ptr)
    442 #define poolLength(pool) ((pool)->ptr - (pool)->start)
    443 #define poolChop(pool) ((void)--(pool->ptr))
    444 #define poolLastChar(pool) (((pool)->ptr)[-1])
    445 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
    446 #define poolFinish(pool) ((pool)->start = (pool)->ptr)
    447 #define poolAppendChar(pool, c) \
    448   (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
    449    ? 0 \
    450    : ((*((pool)->ptr)++ = c), 1))
    451 
    452 struct XML_ParserStruct {
    453   /* The first member must be userData so that the XML_GetUserData
    454      macro works. */
    455   void *m_userData;
    456   void *m_handlerArg;
    457   char *m_buffer;
    458   const XML_Memory_Handling_Suite m_mem;
    459   /* first character to be parsed */
    460   const char *m_bufferPtr;
    461   /* past last character to be parsed */
    462   char *m_bufferEnd;
    463   /* allocated end of buffer */
    464   const char *m_bufferLim;
    465   XML_Index m_parseEndByteIndex;
    466   const char *m_parseEndPtr;
    467   XML_Char *m_dataBuf;
    468   XML_Char *m_dataBufEnd;
    469   XML_StartElementHandler m_startElementHandler;
    470   XML_EndElementHandler m_endElementHandler;
    471   XML_CharacterDataHandler m_characterDataHandler;
    472   XML_ProcessingInstructionHandler m_processingInstructionHandler;
    473   XML_CommentHandler m_commentHandler;
    474   XML_StartCdataSectionHandler m_startCdataSectionHandler;
    475   XML_EndCdataSectionHandler m_endCdataSectionHandler;
    476   XML_DefaultHandler m_defaultHandler;
    477   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
    478   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
    479   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
    480   XML_NotationDeclHandler m_notationDeclHandler;
    481   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
    482   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
    483   XML_NotStandaloneHandler m_notStandaloneHandler;
    484   XML_ExternalEntityRefHandler m_externalEntityRefHandler;
    485   XML_Parser m_externalEntityRefHandlerArg;
    486   XML_SkippedEntityHandler m_skippedEntityHandler;
    487   XML_UnknownEncodingHandler m_unknownEncodingHandler;
    488   XML_ElementDeclHandler m_elementDeclHandler;
    489   XML_AttlistDeclHandler m_attlistDeclHandler;
    490   XML_EntityDeclHandler m_entityDeclHandler;
    491   XML_XmlDeclHandler m_xmlDeclHandler;
    492   const ENCODING *m_encoding;
    493   INIT_ENCODING m_initEncoding;
    494   const ENCODING *m_internalEncoding;
    495   const XML_Char *m_protocolEncodingName;
    496   XML_Bool m_ns;
    497   XML_Bool m_ns_triplets;
    498   void *m_unknownEncodingMem;
    499   void *m_unknownEncodingData;
    500   void *m_unknownEncodingHandlerData;
    501   void (XMLCALL *m_unknownEncodingRelease)(void *);
    502   PROLOG_STATE m_prologState;
    503   Processor *m_processor;
    504   enum XML_Error m_errorCode;
    505   const char *m_eventPtr;
    506   const char *m_eventEndPtr;
    507   const char *m_positionPtr;
    508   OPEN_INTERNAL_ENTITY *m_openInternalEntities;
    509   OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
    510   XML_Bool m_defaultExpandInternalEntities;
    511   int m_tagLevel;
    512   ENTITY *m_declEntity;
    513   const XML_Char *m_doctypeName;
    514   const XML_Char *m_doctypeSysid;
    515   const XML_Char *m_doctypePubid;
    516   const XML_Char *m_declAttributeType;
    517   const XML_Char *m_declNotationName;
    518   const XML_Char *m_declNotationPublicId;
    519   ELEMENT_TYPE *m_declElementType;
    520   ATTRIBUTE_ID *m_declAttributeId;
    521   XML_Bool m_declAttributeIsCdata;
    522   XML_Bool m_declAttributeIsId;
    523   DTD *m_dtd;
    524   const XML_Char *m_curBase;
    525   TAG *m_tagStack;
    526   TAG *m_freeTagList;
    527   BINDING *m_inheritedBindings;
    528   BINDING *m_freeBindingList;
    529   int m_attsSize;
    530   int m_nSpecifiedAtts;
    531   int m_idAttIndex;
    532   ATTRIBUTE *m_atts;
    533   NS_ATT *m_nsAtts;
    534   unsigned long m_nsAttsVersion;
    535   unsigned char m_nsAttsPower;
    536   POSITION m_position;
    537   STRING_POOL m_tempPool;
    538   STRING_POOL m_temp2Pool;
    539   char *m_groupConnector;
    540   unsigned int m_groupSize;
    541   XML_Char m_namespaceSeparator;
    542   XML_Parser m_parentParser;
    543   XML_ParsingStatus m_parsingStatus;
    544 #ifdef XML_DTD
    545   XML_Bool m_isParamEntity;
    546   XML_Bool m_useForeignDTD;
    547   enum XML_ParamEntityParsing m_paramEntityParsing;
    548 #endif
    549 };
    550 
    551 #define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
    552 #define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))
    553 #define FREE(p) (parser->m_mem.free_fcn((p)))
    554 
    555 #define userData (parser->m_userData)
    556 #define handlerArg (parser->m_handlerArg)
    557 #define startElementHandler (parser->m_startElementHandler)
    558 #define endElementHandler (parser->m_endElementHandler)
    559 #define characterDataHandler (parser->m_characterDataHandler)
    560 #define processingInstructionHandler \
    561         (parser->m_processingInstructionHandler)
    562 #define commentHandler (parser->m_commentHandler)
    563 #define startCdataSectionHandler \
    564         (parser->m_startCdataSectionHandler)
    565 #define endCdataSectionHandler (parser->m_endCdataSectionHandler)
    566 #define defaultHandler (parser->m_defaultHandler)
    567 #define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)
    568 #define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)
    569 #define unparsedEntityDeclHandler \
    570         (parser->m_unparsedEntityDeclHandler)
    571 #define notationDeclHandler (parser->m_notationDeclHandler)
    572 #define startNamespaceDeclHandler \
    573         (parser->m_startNamespaceDeclHandler)
    574 #define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)
    575 #define notStandaloneHandler (parser->m_notStandaloneHandler)
    576 #define externalEntityRefHandler \
    577         (parser->m_externalEntityRefHandler)
    578 #define externalEntityRefHandlerArg \
    579         (parser->m_externalEntityRefHandlerArg)
    580 #define internalEntityRefHandler \
    581         (parser->m_internalEntityRefHandler)
    582 #define skippedEntityHandler (parser->m_skippedEntityHandler)
    583 #define unknownEncodingHandler (parser->m_unknownEncodingHandler)
    584 #define elementDeclHandler (parser->m_elementDeclHandler)
    585 #define attlistDeclHandler (parser->m_attlistDeclHandler)
    586 #define entityDeclHandler (parser->m_entityDeclHandler)
    587 #define xmlDeclHandler (parser->m_xmlDeclHandler)
    588 #define encoding (parser->m_encoding)
    589 #define initEncoding (parser->m_initEncoding)
    590 #define internalEncoding (parser->m_internalEncoding)
    591 #define unknownEncodingMem (parser->m_unknownEncodingMem)
    592 #define unknownEncodingData (parser->m_unknownEncodingData)
    593 #define unknownEncodingHandlerData \
    594   (parser->m_unknownEncodingHandlerData)
    595 #define unknownEncodingRelease (parser->m_unknownEncodingRelease)
    596 #define protocolEncodingName (parser->m_protocolEncodingName)
    597 #define ns (parser->m_ns)
    598 #define ns_triplets (parser->m_ns_triplets)
    599 #define prologState (parser->m_prologState)
    600 #define processor (parser->m_processor)
    601 #define errorCode (parser->m_errorCode)
    602 #define eventPtr (parser->m_eventPtr)
    603 #define eventEndPtr (parser->m_eventEndPtr)
    604 #define positionPtr (parser->m_positionPtr)
    605 #define position (parser->m_position)
    606 #define openInternalEntities (parser->m_openInternalEntities)
    607 #define freeInternalEntities (parser->m_freeInternalEntities)
    608 #define defaultExpandInternalEntities \
    609         (parser->m_defaultExpandInternalEntities)
    610 #define tagLevel (parser->m_tagLevel)
    611 #define buffer (parser->m_buffer)
    612 #define bufferPtr (parser->m_bufferPtr)
    613 #define bufferEnd (parser->m_bufferEnd)
    614 #define parseEndByteIndex (parser->m_parseEndByteIndex)
    615 #define parseEndPtr (parser->m_parseEndPtr)
    616 #define bufferLim (parser->m_bufferLim)
    617 #define dataBuf (parser->m_dataBuf)
    618 #define dataBufEnd (parser->m_dataBufEnd)
    619 #define _dtd (parser->m_dtd)
    620 #define curBase (parser->m_curBase)
    621 #define declEntity (parser->m_declEntity)
    622 #define doctypeName (parser->m_doctypeName)
    623 #define doctypeSysid (parser->m_doctypeSysid)
    624 #define doctypePubid (parser->m_doctypePubid)
    625 #define declAttributeType (parser->m_declAttributeType)
    626 #define declNotationName (parser->m_declNotationName)
    627 #define declNotationPublicId (parser->m_declNotationPublicId)
    628 #define declElementType (parser->m_declElementType)
    629 #define declAttributeId (parser->m_declAttributeId)
    630 #define declAttributeIsCdata (parser->m_declAttributeIsCdata)
    631 #define declAttributeIsId (parser->m_declAttributeIsId)
    632 #define freeTagList (parser->m_freeTagList)
    633 #define freeBindingList (parser->m_freeBindingList)
    634 #define inheritedBindings (parser->m_inheritedBindings)
    635 #define tagStack (parser->m_tagStack)
    636 #define atts (parser->m_atts)
    637 #define attsSize (parser->m_attsSize)
    638 #define nSpecifiedAtts (parser->m_nSpecifiedAtts)
    639 #define idAttIndex (parser->m_idAttIndex)
    640 #define nsAtts (parser->m_nsAtts)
    641 #define nsAttsVersion (parser->m_nsAttsVersion)
    642 #define nsAttsPower (parser->m_nsAttsPower)
    643 #define tempPool (parser->m_tempPool)
    644 #define temp2Pool (parser->m_temp2Pool)
    645 #define groupConnector (parser->m_groupConnector)
    646 #define groupSize (parser->m_groupSize)
    647 #define namespaceSeparator (parser->m_namespaceSeparator)
    648 #define parentParser (parser->m_parentParser)
    649 #define ps_parsing (parser->m_parsingStatus.parsing)
    650 #define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)
    651 #ifdef XML_DTD
    652 #define isParamEntity (parser->m_isParamEntity)
    653 #define useForeignDTD (parser->m_useForeignDTD)
    654 #define paramEntityParsing (parser->m_paramEntityParsing)
    655 #endif /* XML_DTD */
    656 
    657 XML_Parser XMLCALL
    658 XML_ParserCreate(const XML_Char *encodingName)
    659 {
    660   return XML_ParserCreate_MM(encodingName, NULL, NULL);
    661 }
    662 
    663 XML_Parser XMLCALL
    664 XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
    665 {
    666   XML_Char tmp[2];
    667   *tmp = nsSep;
    668   return XML_ParserCreate_MM(encodingName, NULL, tmp);
    669 }
    670 
    671 static const XML_Char implicitContext[] = {
    672   ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,
    673   ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,
    674   ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,
    675   ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,
    676   ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
    677   ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'
    678 };
    679 
    680 XML_Parser XMLCALL
    681 XML_ParserCreate_MM(const XML_Char *encodingName,
    682                     const XML_Memory_Handling_Suite *memsuite,
    683                     const XML_Char *nameSep)
    684 {
    685   XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);
    686   if (parser != NULL && ns) {
    687     /* implicit context only set for root parser, since child
    688        parsers (i.e. external entity parsers) will inherit it
    689     */
    690     if (!setContext(parser, implicitContext)) {
    691       XML_ParserFree(parser);
    692       return NULL;
    693     }
    694   }
    695   return parser;
    696 }
    697 
    698 static XML_Parser
    699 parserCreate(const XML_Char *encodingName,
    700              const XML_Memory_Handling_Suite *memsuite,
    701              const XML_Char *nameSep,
    702              DTD *dtd)
    703 {
    704   XML_Parser parser;
    705 
    706   if (memsuite) {
    707     XML_Memory_Handling_Suite *mtemp;
    708     parser = (XML_Parser)
    709       memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
    710     if (parser != NULL) {
    711       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
    712       mtemp->malloc_fcn = memsuite->malloc_fcn;
    713       mtemp->realloc_fcn = memsuite->realloc_fcn;
    714       mtemp->free_fcn = memsuite->free_fcn;
    715     }
    716   }
    717   else {
    718     XML_Memory_Handling_Suite *mtemp;
    719     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
    720     if (parser != NULL) {
    721       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
    722       mtemp->malloc_fcn = malloc;
    723       mtemp->realloc_fcn = realloc;
    724       mtemp->free_fcn = free;
    725     }
    726   }
    727 
    728   if (!parser)
    729     return parser;
    730 
    731   buffer = NULL;
    732   bufferLim = NULL;
    733 
    734   attsSize = INIT_ATTS_SIZE;
    735   atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));
    736   if (atts == NULL) {
    737     FREE(parser);
    738     return NULL;
    739   }
    740   dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
    741   if (dataBuf == NULL) {
    742     FREE(atts);
    743     FREE(parser);
    744     return NULL;
    745   }
    746   dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
    747 
    748   if (dtd)
    749     _dtd = dtd;
    750   else {
    751     _dtd = dtdCreate(&parser->m_mem);
    752     if (_dtd == NULL) {
    753       FREE(dataBuf);
    754       FREE(atts);
    755       FREE(parser);
    756       return NULL;
    757     }
    758   }
    759 
    760   freeBindingList = NULL;
    761   freeTagList = NULL;
    762   freeInternalEntities = NULL;
    763 
    764   groupSize = 0;
    765   groupConnector = NULL;
    766 
    767   unknownEncodingHandler = NULL;
    768   unknownEncodingHandlerData = NULL;
    769 
    770   namespaceSeparator = ASCII_EXCL;
    771   ns = XML_FALSE;
    772   ns_triplets = XML_FALSE;
    773 
    774   nsAtts = NULL;
    775   nsAttsVersion = 0;
    776   nsAttsPower = 0;
    777 
    778   poolInit(&tempPool, &(parser->m_mem));
    779   poolInit(&temp2Pool, &(parser->m_mem));
    780   parserInit(parser, encodingName);
    781 
    782   if (encodingName && !protocolEncodingName) {
    783     XML_ParserFree(parser);
    784     return NULL;
    785   }
    786 
    787   if (nameSep) {
    788     ns = XML_TRUE;
    789     internalEncoding = XmlGetInternalEncodingNS();
    790     namespaceSeparator = *nameSep;
    791   }
    792   else {
    793     internalEncoding = XmlGetInternalEncoding();
    794   }
    795 
    796   return parser;
    797 }
    798 
    799 static void
    800 parserInit(XML_Parser parser, const XML_Char *encodingName)
    801 {
    802   processor = prologInitProcessor;
    803   XmlPrologStateInit(&prologState);
    804   protocolEncodingName = (encodingName != NULL
    805                           ? poolCopyString(&tempPool, encodingName)
    806                           : NULL);
    807   curBase = NULL;
    808   XmlInitEncoding(&initEncoding, &encoding, 0);
    809   userData = NULL;
    810   handlerArg = NULL;
    811   startElementHandler = NULL;
    812   endElementHandler = NULL;
    813   characterDataHandler = NULL;
    814   processingInstructionHandler = NULL;
    815   commentHandler = NULL;
    816   startCdataSectionHandler = NULL;
    817   endCdataSectionHandler = NULL;
    818   defaultHandler = NULL;
    819   startDoctypeDeclHandler = NULL;
    820   endDoctypeDeclHandler = NULL;
    821   unparsedEntityDeclHandler = NULL;
    822   notationDeclHandler = NULL;
    823   startNamespaceDeclHandler = NULL;
    824   endNamespaceDeclHandler = NULL;
    825   notStandaloneHandler = NULL;
    826   externalEntityRefHandler = NULL;
    827   externalEntityRefHandlerArg = parser;
    828   skippedEntityHandler = NULL;
    829   elementDeclHandler = NULL;
    830   attlistDeclHandler = NULL;
    831   entityDeclHandler = NULL;
    832   xmlDeclHandler = NULL;
    833   bufferPtr = buffer;
    834   bufferEnd = buffer;
    835   parseEndByteIndex = 0;
    836   parseEndPtr = NULL;
    837   declElementType = NULL;
    838   declAttributeId = NULL;
    839   declEntity = NULL;
    840   doctypeName = NULL;
    841   doctypeSysid = NULL;
    842   doctypePubid = NULL;
    843   declAttributeType = NULL;
    844   declNotationName = NULL;
    845   declNotationPublicId = NULL;
    846   declAttributeIsCdata = XML_FALSE;
    847   declAttributeIsId = XML_FALSE;
    848   memset(&position, 0, sizeof(POSITION));
    849   errorCode = XML_ERROR_NONE;
    850   eventPtr = NULL;
    851   eventEndPtr = NULL;
    852   positionPtr = NULL;
    853   openInternalEntities = NULL;
    854   defaultExpandInternalEntities = XML_TRUE;
    855   tagLevel = 0;
    856   tagStack = NULL;
    857   inheritedBindings = NULL;
    858   nSpecifiedAtts = 0;
    859   unknownEncodingMem = NULL;
    860   unknownEncodingRelease = NULL;
    861   unknownEncodingData = NULL;
    862   parentParser = NULL;
    863   ps_parsing = XML_INITIALIZED;
    864 #ifdef XML_DTD
    865   isParamEntity = XML_FALSE;
    866   useForeignDTD = XML_FALSE;
    867   paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
    868 #endif
    869 }
    870 
    871 /* moves list of bindings to freeBindingList */
    872 static void FASTCALL
    873 moveToFreeBindingList(XML_Parser parser, BINDING *bindings)
    874 {
    875   while (bindings) {
    876     BINDING *b = bindings;
    877     bindings = bindings->nextTagBinding;
    878     b->nextTagBinding = freeBindingList;
    879     freeBindingList = b;
    880   }
    881 }
    882 
    883 XML_Bool XMLCALL
    884 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)
    885 {
    886   TAG *tStk;
    887   OPEN_INTERNAL_ENTITY *openEntityList;
    888   if (parentParser)
    889     return XML_FALSE;
    890   /* move tagStack to freeTagList */
    891   tStk = tagStack;
    892   while (tStk) {
    893     TAG *tag = tStk;
    894     tStk = tStk->parent;
    895     tag->parent = freeTagList;
    896     moveToFreeBindingList(parser, tag->bindings);
    897     tag->bindings = NULL;
    898     freeTagList = tag;
    899   }
    900   /* move openInternalEntities to freeInternalEntities */
    901   openEntityList = openInternalEntities;
    902   while (openEntityList) {
    903     OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
    904     openEntityList = openEntity->next;
    905     openEntity->next = freeInternalEntities;
    906     freeInternalEntities = openEntity;
    907   }
    908   moveToFreeBindingList(parser, inheritedBindings);
    909   FREE(unknownEncodingMem);
    910   if (unknownEncodingRelease)
    911     unknownEncodingRelease(unknownEncodingData);
    912   poolClear(&tempPool);
    913   poolClear(&temp2Pool);
    914   parserInit(parser, encodingName);
    915   dtdReset(_dtd, &parser->m_mem);
    916   return setContext(parser, implicitContext);
    917 }
    918 
    919 enum XML_Status XMLCALL
    920 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
    921 {
    922   /* Block after XML_Parse()/XML_ParseBuffer() has been called.
    923      XXX There's no way for the caller to determine which of the
    924      XXX possible error cases caused the XML_STATUS_ERROR return.
    925   */
    926   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
    927     return XML_STATUS_ERROR;
    928   if (encodingName == NULL)
    929     protocolEncodingName = NULL;
    930   else {
    931     protocolEncodingName = poolCopyString(&tempPool, encodingName);
    932     if (!protocolEncodingName)
    933       return XML_STATUS_ERROR;
    934   }
    935   return XML_STATUS_OK;
    936 }
    937 
    938 XML_Parser XMLCALL
    939 XML_ExternalEntityParserCreate(XML_Parser oldParser,
    940                                const XML_Char *context,
    941                                const XML_Char *encodingName)
    942 {
    943   XML_Parser parser = oldParser;
    944   DTD *newDtd = NULL;
    945   DTD *oldDtd = _dtd;
    946   XML_StartElementHandler oldStartElementHandler = startElementHandler;
    947   XML_EndElementHandler oldEndElementHandler = endElementHandler;
    948   XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
    949   XML_ProcessingInstructionHandler oldProcessingInstructionHandler
    950       = processingInstructionHandler;
    951   XML_CommentHandler oldCommentHandler = commentHandler;
    952   XML_StartCdataSectionHandler oldStartCdataSectionHandler
    953       = startCdataSectionHandler;
    954   XML_EndCdataSectionHandler oldEndCdataSectionHandler
    955       = endCdataSectionHandler;
    956   XML_DefaultHandler oldDefaultHandler = defaultHandler;
    957   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler
    958       = unparsedEntityDeclHandler;
    959   XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;
    960   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler
    961       = startNamespaceDeclHandler;
    962   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler
    963       = endNamespaceDeclHandler;
    964   XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
    965   XML_ExternalEntityRefHandler oldExternalEntityRefHandler
    966       = externalEntityRefHandler;
    967   XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;
    968   XML_UnknownEncodingHandler oldUnknownEncodingHandler
    969       = unknownEncodingHandler;
    970   XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;
    971   XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;
    972   XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;
    973   XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;
    974   ELEMENT_TYPE * oldDeclElementType = declElementType;
    975 
    976   void *oldUserData = userData;
    977   void *oldHandlerArg = handlerArg;
    978   XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
    979   XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
    980 #ifdef XML_DTD
    981   enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;
    982   int oldInEntityValue = prologState.inEntityValue;
    983 #endif
    984   XML_Bool oldns_triplets = ns_triplets;
    985 
    986 #ifdef XML_DTD
    987   if (!context)
    988     newDtd = oldDtd;
    989 #endif /* XML_DTD */
    990 
    991   /* Note that the magical uses of the pre-processor to make field
    992      access look more like C++ require that `parser' be overwritten
    993      here.  This makes this function more painful to follow than it
    994      would be otherwise.
    995   */
    996   if (ns) {
    997     XML_Char tmp[2];
    998     *tmp = namespaceSeparator;
    999     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
   1000   }
   1001   else {
   1002     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
   1003   }
   1004 
   1005   if (!parser)
   1006     return NULL;
   1007 
   1008   startElementHandler = oldStartElementHandler;
   1009   endElementHandler = oldEndElementHandler;
   1010   characterDataHandler = oldCharacterDataHandler;
   1011   processingInstructionHandler = oldProcessingInstructionHandler;
   1012   commentHandler = oldCommentHandler;
   1013   startCdataSectionHandler = oldStartCdataSectionHandler;
   1014   endCdataSectionHandler = oldEndCdataSectionHandler;
   1015   defaultHandler = oldDefaultHandler;
   1016   unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
   1017   notationDeclHandler = oldNotationDeclHandler;
   1018   startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
   1019   endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
   1020   notStandaloneHandler = oldNotStandaloneHandler;
   1021   externalEntityRefHandler = oldExternalEntityRefHandler;
   1022   skippedEntityHandler = oldSkippedEntityHandler;
   1023   unknownEncodingHandler = oldUnknownEncodingHandler;
   1024   elementDeclHandler = oldElementDeclHandler;
   1025   attlistDeclHandler = oldAttlistDeclHandler;
   1026   entityDeclHandler = oldEntityDeclHandler;
   1027   xmlDeclHandler = oldXmlDeclHandler;
   1028   declElementType = oldDeclElementType;
   1029   userData = oldUserData;
   1030   if (oldUserData == oldHandlerArg)
   1031     handlerArg = userData;
   1032   else
   1033     handlerArg = parser;
   1034   if (oldExternalEntityRefHandlerArg != oldParser)
   1035     externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
   1036   defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
   1037   ns_triplets = oldns_triplets;
   1038   parentParser = oldParser;
   1039 #ifdef XML_DTD
   1040   paramEntityParsing = oldParamEntityParsing;
   1041   prologState.inEntityValue = oldInEntityValue;
   1042   if (context) {
   1043 #endif /* XML_DTD */
   1044     if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)
   1045       || !setContext(parser, context)) {
   1046       XML_ParserFree(parser);
   1047       return NULL;
   1048     }
   1049     processor = externalEntityInitProcessor;
   1050 #ifdef XML_DTD
   1051   }
   1052   else {
   1053     /* The DTD instance referenced by _dtd is shared between the document's
   1054        root parser and external PE parsers, therefore one does not need to
   1055        call setContext. In addition, one also *must* not call setContext,
   1056        because this would overwrite existing prefix->binding pointers in
   1057        _dtd with ones that get destroyed with the external PE parser.
   1058        This would leave those prefixes with dangling pointers.
   1059     */
   1060     isParamEntity = XML_TRUE;
   1061     XmlPrologStateInitExternalEntity(&prologState);
   1062     processor = externalParEntInitProcessor;
   1063   }
   1064 #endif /* XML_DTD */
   1065   return parser;
   1066 }
   1067 
   1068 static void FASTCALL
   1069 destroyBindings(BINDING *bindings, XML_Parser parser)
   1070 {
   1071   for (;;) {
   1072     BINDING *b = bindings;
   1073     if (!b)
   1074       break;
   1075     bindings = b->nextTagBinding;
   1076     FREE(b->uri);
   1077     FREE(b);
   1078   }
   1079 }
   1080 
   1081 void XMLCALL
   1082 XML_ParserFree(XML_Parser parser)
   1083 {
   1084   TAG *tagList;
   1085   OPEN_INTERNAL_ENTITY *entityList;
   1086   if (parser == NULL)
   1087     return;
   1088   /* free tagStack and freeTagList */
   1089   tagList = tagStack;
   1090   for (;;) {
   1091     TAG *p;
   1092     if (tagList == NULL) {
   1093       if (freeTagList == NULL)
   1094         break;
   1095       tagList = freeTagList;
   1096       freeTagList = NULL;
   1097     }
   1098     p = tagList;
   1099     tagList = tagList->parent;
   1100     FREE(p->buf);
   1101     destroyBindings(p->bindings, parser);
   1102     FREE(p);
   1103   }
   1104   /* free openInternalEntities and freeInternalEntities */
   1105   entityList = openInternalEntities;
   1106   for (;;) {
   1107     OPEN_INTERNAL_ENTITY *openEntity;
   1108     if (entityList == NULL) {
   1109       if (freeInternalEntities == NULL)
   1110         break;
   1111       entityList = freeInternalEntities;
   1112       freeInternalEntities = NULL;
   1113     }
   1114     openEntity = entityList;
   1115     entityList = entityList->next;
   1116     FREE(openEntity);
   1117   }
   1118 
   1119   destroyBindings(freeBindingList, parser);
   1120   destroyBindings(inheritedBindings, parser);
   1121   poolDestroy(&tempPool);
   1122   poolDestroy(&temp2Pool);
   1123 #ifdef XML_DTD
   1124   /* external parameter entity parsers share the DTD structure
   1125      parser->m_dtd with the root parser, so we must not destroy it
   1126   */
   1127   if (!isParamEntity && _dtd)
   1128 #else
   1129   if (_dtd)
   1130 #endif /* XML_DTD */
   1131     dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
   1132   FREE((void *)atts);
   1133   FREE(groupConnector);
   1134   FREE(buffer);
   1135   FREE(dataBuf);
   1136   FREE(nsAtts);
   1137   FREE(unknownEncodingMem);
   1138   if (unknownEncodingRelease)
   1139     unknownEncodingRelease(unknownEncodingData);
   1140   FREE(parser);
   1141 }
   1142 
   1143 void XMLCALL
   1144 XML_UseParserAsHandlerArg(XML_Parser parser)
   1145 {
   1146   handlerArg = parser;
   1147 }
   1148 
   1149 enum XML_Error XMLCALL
   1150 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
   1151 {
   1152 #ifdef XML_DTD
   1153   /* block after XML_Parse()/XML_ParseBuffer() has been called */
   1154   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
   1155     return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
   1156   useForeignDTD = useDTD;
   1157   return XML_ERROR_NONE;
   1158 #else
   1159   return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
   1160 #endif
   1161 }
   1162 
   1163 void XMLCALL
   1164 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
   1165 {
   1166   /* block after XML_Parse()/XML_ParseBuffer() has been called */
   1167   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
   1168     return;
   1169   ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
   1170 }
   1171 
   1172 void XMLCALL
   1173 XML_SetUserData(XML_Parser parser, void *p)
   1174 {
   1175   if (handlerArg == userData)
   1176     handlerArg = userData = p;
   1177   else
   1178     userData = p;
   1179 }
   1180 
   1181 enum XML_Status XMLCALL
   1182 XML_SetBase(XML_Parser parser, const XML_Char *p)
   1183 {
   1184   if (p) {
   1185     p = poolCopyString(&_dtd->pool, p);
   1186     if (!p)
   1187       return XML_STATUS_ERROR;
   1188     curBase = p;
   1189   }
   1190   else
   1191     curBase = NULL;
   1192   return XML_STATUS_OK;
   1193 }
   1194 
   1195 const XML_Char * XMLCALL
   1196 XML_GetBase(XML_Parser parser)
   1197 {
   1198   return curBase;
   1199 }
   1200 
   1201 int XMLCALL
   1202 XML_GetSpecifiedAttributeCount(XML_Parser parser)
   1203 {
   1204   return nSpecifiedAtts;
   1205 }
   1206 
   1207 int XMLCALL
   1208 XML_GetIdAttributeIndex(XML_Parser parser)
   1209 {
   1210   return idAttIndex;
   1211 }
   1212 
   1213 void XMLCALL
   1214 XML_SetElementHandler(XML_Parser parser,
   1215                       XML_StartElementHandler start,
   1216                       XML_EndElementHandler end)
   1217 {
   1218   startElementHandler = start;
   1219   endElementHandler = end;
   1220 }
   1221 
   1222 void XMLCALL
   1223 XML_SetStartElementHandler(XML_Parser parser,
   1224                            XML_StartElementHandler start) {
   1225   startElementHandler = start;
   1226 }
   1227 
   1228 void XMLCALL
   1229 XML_SetEndElementHandler(XML_Parser parser,
   1230                          XML_EndElementHandler end) {
   1231   endElementHandler = end;
   1232 }
   1233 
   1234 void XMLCALL
   1235 XML_SetCharacterDataHandler(XML_Parser parser,
   1236                             XML_CharacterDataHandler handler)
   1237 {
   1238   characterDataHandler = handler;
   1239 }
   1240 
   1241 void XMLCALL
   1242 XML_SetProcessingInstructionHandler(XML_Parser parser,
   1243                                     XML_ProcessingInstructionHandler handler)
   1244 {
   1245   processingInstructionHandler = handler;
   1246 }
   1247 
   1248 void XMLCALL
   1249 XML_SetCommentHandler(XML_Parser parser,
   1250                       XML_CommentHandler handler)
   1251 {
   1252   commentHandler = handler;
   1253 }
   1254 
   1255 void XMLCALL
   1256 XML_SetCdataSectionHandler(XML_Parser parser,
   1257                            XML_StartCdataSectionHandler start,
   1258                            XML_EndCdataSectionHandler end)
   1259 {
   1260   startCdataSectionHandler = start;
   1261   endCdataSectionHandler = end;
   1262 }
   1263 
   1264 void XMLCALL
   1265 XML_SetStartCdataSectionHandler(XML_Parser parser,
   1266                                 XML_StartCdataSectionHandler start) {
   1267   startCdataSectionHandler = start;
   1268 }
   1269 
   1270 void XMLCALL
   1271 XML_SetEndCdataSectionHandler(XML_Parser parser,
   1272                               XML_EndCdataSectionHandler end) {
   1273   endCdataSectionHandler = end;
   1274 }
   1275 
   1276 void XMLCALL
   1277 XML_SetDefaultHandler(XML_Parser parser,
   1278                       XML_DefaultHandler handler)
   1279 {
   1280   defaultHandler = handler;
   1281   defaultExpandInternalEntities = XML_FALSE;
   1282 }
   1283 
   1284 void XMLCALL
   1285 XML_SetDefaultHandlerExpand(XML_Parser parser,
   1286                             XML_DefaultHandler handler)
   1287 {
   1288   defaultHandler = handler;
   1289   defaultExpandInternalEntities = XML_TRUE;
   1290 }
   1291 
   1292 void XMLCALL
   1293 XML_SetDoctypeDeclHandler(XML_Parser parser,
   1294                           XML_StartDoctypeDeclHandler start,
   1295                           XML_EndDoctypeDeclHandler end)
   1296 {
   1297   startDoctypeDeclHandler = start;
   1298   endDoctypeDeclHandler = end;
   1299 }
   1300 
   1301 void XMLCALL
   1302 XML_SetStartDoctypeDeclHandler(XML_Parser parser,
   1303                                XML_StartDoctypeDeclHandler start) {
   1304   startDoctypeDeclHandler = start;
   1305 }
   1306 
   1307 void XMLCALL
   1308 XML_SetEndDoctypeDeclHandler(XML_Parser parser,
   1309                              XML_EndDoctypeDeclHandler end) {
   1310   endDoctypeDeclHandler = end;
   1311 }
   1312 
   1313 void XMLCALL
   1314 XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
   1315                                  XML_UnparsedEntityDeclHandler handler)
   1316 {
   1317   unparsedEntityDeclHandler = handler;
   1318 }
   1319 
   1320 void XMLCALL
   1321 XML_SetNotationDeclHandler(XML_Parser parser,
   1322                            XML_NotationDeclHandler handler)
   1323 {
   1324   notationDeclHandler = handler;
   1325 }
   1326 
   1327 void XMLCALL
   1328 XML_SetNamespaceDeclHandler(XML_Parser parser,
   1329                             XML_StartNamespaceDeclHandler start,
   1330                             XML_EndNamespaceDeclHandler end)
   1331 {
   1332   startNamespaceDeclHandler = start;
   1333   endNamespaceDeclHandler = end;
   1334 }
   1335 
   1336 void XMLCALL
   1337 XML_SetStartNamespaceDeclHandler(XML_Parser parser,
   1338                                  XML_StartNamespaceDeclHandler start) {
   1339   startNamespaceDeclHandler = start;
   1340 }
   1341 
   1342 void XMLCALL
   1343 XML_SetEndNamespaceDeclHandler(XML_Parser parser,
   1344                                XML_EndNamespaceDeclHandler end) {
   1345   endNamespaceDeclHandler = end;
   1346 }
   1347 
   1348 void XMLCALL
   1349 XML_SetNotStandaloneHandler(XML_Parser parser,
   1350                             XML_NotStandaloneHandler handler)
   1351 {
   1352   notStandaloneHandler = handler;
   1353 }
   1354 
   1355 void XMLCALL
   1356 XML_SetExternalEntityRefHandler(XML_Parser parser,
   1357                                 XML_ExternalEntityRefHandler handler)
   1358 {
   1359   externalEntityRefHandler = handler;
   1360 }
   1361 
   1362 void XMLCALL
   1363 XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
   1364 {
   1365   if (arg)
   1366     externalEntityRefHandlerArg = (XML_Parser)arg;
   1367   else
   1368     externalEntityRefHandlerArg = parser;
   1369 }
   1370 
   1371 void XMLCALL
   1372 XML_SetSkippedEntityHandler(XML_Parser parser,
   1373                             XML_SkippedEntityHandler handler)
   1374 {
   1375   skippedEntityHandler = handler;
   1376 }
   1377 
   1378 void XMLCALL
   1379 XML_SetUnknownEncodingHandler(XML_Parser parser,
   1380                               XML_UnknownEncodingHandler handler,
   1381                               void *data)
   1382 {
   1383   unknownEncodingHandler = handler;
   1384   unknownEncodingHandlerData = data;
   1385 }
   1386 
   1387 void XMLCALL
   1388 XML_SetElementDeclHandler(XML_Parser parser,
   1389                           XML_ElementDeclHandler eldecl)
   1390 {
   1391   elementDeclHandler = eldecl;
   1392 }
   1393 
   1394 void XMLCALL
   1395 XML_SetAttlistDeclHandler(XML_Parser parser,
   1396                           XML_AttlistDeclHandler attdecl)
   1397 {
   1398   attlistDeclHandler = attdecl;
   1399 }
   1400 
   1401 void XMLCALL
   1402 XML_SetEntityDeclHandler(XML_Parser parser,
   1403                          XML_EntityDeclHandler handler)
   1404 {
   1405   entityDeclHandler = handler;
   1406 }
   1407 
   1408 void XMLCALL
   1409 XML_SetXmlDeclHandler(XML_Parser parser,
   1410                       XML_XmlDeclHandler handler) {
   1411   xmlDeclHandler = handler;
   1412 }
   1413 
   1414 int XMLCALL
   1415 XML_SetParamEntityParsing(XML_Parser parser,
   1416                           enum XML_ParamEntityParsing peParsing)
   1417 {
   1418   /* block after XML_Parse()/XML_ParseBuffer() has been called */
   1419   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
   1420     return 0;
   1421 #ifdef XML_DTD
   1422   paramEntityParsing = peParsing;
   1423   return 1;
   1424 #else
   1425   return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
   1426 #endif
   1427 }
   1428 
   1429 enum XML_Status XMLCALL
   1430 XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
   1431 {
   1432   switch (ps_parsing) {
   1433   case XML_SUSPENDED:
   1434     errorCode = XML_ERROR_SUSPENDED;
   1435     return XML_STATUS_ERROR;
   1436   case XML_FINISHED:
   1437     errorCode = XML_ERROR_FINISHED;
   1438     return XML_STATUS_ERROR;
   1439   default:
   1440     ps_parsing = XML_PARSING;
   1441   }
   1442 
   1443   if (len == 0) {
   1444     ps_finalBuffer = (XML_Bool)isFinal;
   1445     if (!isFinal)
   1446       return XML_STATUS_OK;
   1447     positionPtr = bufferPtr;
   1448     parseEndPtr = bufferEnd;
   1449 
   1450     /* If data are left over from last buffer, and we now know that these
   1451        data are the final chunk of input, then we have to check them again
   1452        to detect errors based on that fact.
   1453     */
   1454     errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
   1455 
   1456     if (errorCode == XML_ERROR_NONE) {
   1457       switch (ps_parsing) {
   1458       case XML_SUSPENDED:
   1459         XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
   1460         positionPtr = bufferPtr;
   1461         return XML_STATUS_SUSPENDED;
   1462       case XML_INITIALIZED:
   1463       case XML_PARSING:
   1464         ps_parsing = XML_FINISHED;
   1465         /* fall through */
   1466       default:
   1467         return XML_STATUS_OK;
   1468       }
   1469     }
   1470     eventEndPtr = eventPtr;
   1471     processor = errorProcessor;
   1472     return XML_STATUS_ERROR;
   1473   }
   1474 #ifndef XML_CONTEXT_BYTES
   1475   else if (bufferPtr == bufferEnd) {
   1476     const char *end;
   1477     int nLeftOver;
   1478     enum XML_Error result;
   1479     parseEndByteIndex += len;
   1480     positionPtr = s;
   1481     ps_finalBuffer = (XML_Bool)isFinal;
   1482 
   1483     errorCode = processor(parser, s, parseEndPtr = s + len, &end);
   1484 
   1485     if (errorCode != XML_ERROR_NONE) {
   1486       eventEndPtr = eventPtr;
   1487       processor = errorProcessor;
   1488       return XML_STATUS_ERROR;
   1489     }
   1490     else {
   1491       switch (ps_parsing) {
   1492       case XML_SUSPENDED:
   1493         result = XML_STATUS_SUSPENDED;
   1494         break;
   1495       case XML_INITIALIZED:
   1496       case XML_PARSING:
   1497         result = XML_STATUS_OK;
   1498         if (isFinal) {
   1499           ps_parsing = XML_FINISHED;
   1500           return result;
   1501         }
   1502       }
   1503     }
   1504 
   1505     XmlUpdatePosition(encoding, positionPtr, end, &position);
   1506     nLeftOver = s + len - end;
   1507     if (nLeftOver) {
   1508       if (buffer == NULL || nLeftOver > bufferLim - buffer) {
   1509         /* FIXME avoid integer overflow */
   1510         char *temp;
   1511         temp = (buffer == NULL
   1512                 ? (char *)MALLOC(len * 2)
   1513                 : (char *)REALLOC(buffer, len * 2));
   1514         if (temp == NULL) {
   1515           errorCode = XML_ERROR_NO_MEMORY;
   1516           return XML_STATUS_ERROR;
   1517         }
   1518         buffer = temp;
   1519         if (!buffer) {
   1520           errorCode = XML_ERROR_NO_MEMORY;
   1521           eventPtr = eventEndPtr = NULL;
   1522           processor = errorProcessor;
   1523           return XML_STATUS_ERROR;
   1524         }
   1525         bufferLim = buffer + len * 2;
   1526       }
   1527       memcpy(buffer, end, nLeftOver);
   1528     }
   1529     bufferPtr = buffer;
   1530     bufferEnd = buffer + nLeftOver;
   1531     positionPtr = bufferPtr;
   1532     parseEndPtr = bufferEnd;
   1533     eventPtr = bufferPtr;
   1534     eventEndPtr = bufferPtr;
   1535     return result;
   1536   }
   1537 #endif  /* not defined XML_CONTEXT_BYTES */
   1538   else {
   1539     void *buff = XML_GetBuffer(parser, len);
   1540     if (buff == NULL)
   1541       return XML_STATUS_ERROR;
   1542     else {
   1543       memcpy(buff, s, len);
   1544       return XML_ParseBuffer(parser, len, isFinal);
   1545     }
   1546   }
   1547 }
   1548 
   1549 enum XML_Status XMLCALL
   1550 XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
   1551 {
   1552   const char *start;
   1553   enum XML_Status result = XML_STATUS_OK;
   1554 
   1555   switch (ps_parsing) {
   1556   case XML_SUSPENDED:
   1557     errorCode = XML_ERROR_SUSPENDED;
   1558     return XML_STATUS_ERROR;
   1559   case XML_FINISHED:
   1560     errorCode = XML_ERROR_FINISHED;
   1561     return XML_STATUS_ERROR;
   1562   default:
   1563     ps_parsing = XML_PARSING;
   1564   }
   1565 
   1566   start = bufferPtr;
   1567   positionPtr = start;
   1568   bufferEnd += len;
   1569   parseEndPtr = bufferEnd;
   1570   parseEndByteIndex += len;
   1571   ps_finalBuffer = (XML_Bool)isFinal;
   1572 
   1573   errorCode = processor(parser, start, parseEndPtr, &bufferPtr);
   1574 
   1575   if (errorCode != XML_ERROR_NONE) {
   1576     eventEndPtr = eventPtr;
   1577     processor = errorProcessor;
   1578     return XML_STATUS_ERROR;
   1579   }
   1580   else {
   1581     switch (ps_parsing) {
   1582     case XML_SUSPENDED:
   1583       result = XML_STATUS_SUSPENDED;
   1584       break;
   1585     case XML_INITIALIZED:
   1586     case XML_PARSING:
   1587       if (isFinal) {
   1588         ps_parsing = XML_FINISHED;
   1589         return result;
   1590       }
   1591     default: ;  /* should not happen */
   1592     }
   1593   }
   1594 
   1595   XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
   1596   positionPtr = bufferPtr;
   1597   return result;
   1598 }
   1599 
   1600 void * XMLCALL
   1601 XML_GetBuffer(XML_Parser parser, int len)
   1602 {
   1603   switch (ps_parsing) {
   1604   case XML_SUSPENDED:
   1605     errorCode = XML_ERROR_SUSPENDED;
   1606     return NULL;
   1607   case XML_FINISHED:
   1608     errorCode = XML_ERROR_FINISHED;
   1609     return NULL;
   1610   default: ;
   1611   }
   1612 
   1613   if (len > bufferLim - bufferEnd) {
   1614     /* FIXME avoid integer overflow */
   1615     int neededSize = len + (int)(bufferEnd - bufferPtr);
   1616 #ifdef XML_CONTEXT_BYTES
   1617     int keep = (int)(bufferPtr - buffer);
   1618 
   1619     if (keep > XML_CONTEXT_BYTES)
   1620       keep = XML_CONTEXT_BYTES;
   1621     neededSize += keep;
   1622 #endif  /* defined XML_CONTEXT_BYTES */
   1623     if (neededSize  <= bufferLim - buffer) {
   1624 #ifdef XML_CONTEXT_BYTES
   1625       if (keep < bufferPtr - buffer) {
   1626         int offset = (int)(bufferPtr - buffer) - keep;
   1627         memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
   1628         bufferEnd -= offset;
   1629         bufferPtr -= offset;
   1630       }
   1631 #else
   1632       memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
   1633       bufferEnd = buffer + (bufferEnd - bufferPtr);
   1634       bufferPtr = buffer;
   1635 #endif  /* not defined XML_CONTEXT_BYTES */
   1636     }
   1637     else {
   1638       char *newBuf;
   1639       int bufferSize = (int)(bufferLim - bufferPtr);
   1640       if (bufferSize == 0)
   1641         bufferSize = INIT_BUFFER_SIZE;
   1642       do {
   1643         bufferSize *= 2;
   1644       } while (bufferSize < neededSize);
   1645       newBuf = (char *)MALLOC(bufferSize);
   1646       if (newBuf == 0) {
   1647         errorCode = XML_ERROR_NO_MEMORY;
   1648         return NULL;
   1649       }
   1650       bufferLim = newBuf + bufferSize;
   1651 #ifdef XML_CONTEXT_BYTES
   1652       if (bufferPtr) {
   1653         int keep = (int)(bufferPtr - buffer);
   1654         if (keep > XML_CONTEXT_BYTES)
   1655           keep = XML_CONTEXT_BYTES;
   1656         memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
   1657         FREE(buffer);
   1658         buffer = newBuf;
   1659         bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
   1660         bufferPtr = buffer + keep;
   1661       }
   1662       else {
   1663         bufferEnd = newBuf + (bufferEnd - bufferPtr);
   1664         bufferPtr = buffer = newBuf;
   1665       }
   1666 #else
   1667       if (bufferPtr) {
   1668         memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
   1669         FREE(buffer);
   1670       }
   1671       bufferEnd = newBuf + (bufferEnd - bufferPtr);
   1672       bufferPtr = buffer = newBuf;
   1673 #endif  /* not defined XML_CONTEXT_BYTES */
   1674     }
   1675   }
   1676   return bufferEnd;
   1677 }
   1678 
   1679 enum XML_Status XMLCALL
   1680 XML_StopParser(XML_Parser parser, XML_Bool resumable)
   1681 {
   1682   switch (ps_parsing) {
   1683   case XML_SUSPENDED:
   1684     if (resumable) {
   1685       errorCode = XML_ERROR_SUSPENDED;
   1686       return XML_STATUS_ERROR;
   1687     }
   1688     ps_parsing = XML_FINISHED;
   1689     break;
   1690   case XML_FINISHED:
   1691     errorCode = XML_ERROR_FINISHED;
   1692     return XML_STATUS_ERROR;
   1693   default:
   1694     if (resumable) {
   1695 #ifdef XML_DTD
   1696       if (isParamEntity) {
   1697         errorCode = XML_ERROR_SUSPEND_PE;
   1698         return XML_STATUS_ERROR;
   1699       }
   1700 #endif
   1701       ps_parsing = XML_SUSPENDED;
   1702     }
   1703     else
   1704       ps_parsing = XML_FINISHED;
   1705   }
   1706   return XML_STATUS_OK;
   1707 }
   1708 
   1709 enum XML_Status XMLCALL
   1710 XML_ResumeParser(XML_Parser parser)
   1711 {
   1712   enum XML_Status result = XML_STATUS_OK;
   1713 
   1714   if (ps_parsing != XML_SUSPENDED) {
   1715     errorCode = XML_ERROR_NOT_SUSPENDED;
   1716     return XML_STATUS_ERROR;
   1717   }
   1718   ps_parsing = XML_PARSING;
   1719 
   1720   errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
   1721 
   1722   if (errorCode != XML_ERROR_NONE) {
   1723     eventEndPtr = eventPtr;
   1724     processor = errorProcessor;
   1725     return XML_STATUS_ERROR;
   1726   }
   1727   else {
   1728     switch (ps_parsing) {
   1729     case XML_SUSPENDED:
   1730       result = XML_STATUS_SUSPENDED;
   1731       break;
   1732     case XML_INITIALIZED:
   1733     case XML_PARSING:
   1734       if (ps_finalBuffer) {
   1735         ps_parsing = XML_FINISHED;
   1736         return result;
   1737       }
   1738     default: ;
   1739     }
   1740   }
   1741 
   1742   XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
   1743   positionPtr = bufferPtr;
   1744   return result;
   1745 }
   1746 
   1747 void XMLCALL
   1748 XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)
   1749 {
   1750   assert(status != NULL);
   1751   *status = parser->m_parsingStatus;
   1752 }
   1753 
   1754 enum XML_Error XMLCALL
   1755 XML_GetErrorCode(XML_Parser parser)
   1756 {
   1757   return errorCode;
   1758 }
   1759 
   1760 XML_Index XMLCALL
   1761 XML_GetCurrentByteIndex(XML_Parser parser)
   1762 {
   1763   if (eventPtr)
   1764     return parseEndByteIndex - (parseEndPtr - eventPtr);
   1765   return -1;
   1766 }
   1767 
   1768 int XMLCALL
   1769 XML_GetCurrentByteCount(XML_Parser parser)
   1770 {
   1771   if (eventEndPtr && eventPtr)
   1772     return (int)(eventEndPtr - eventPtr);
   1773   return 0;
   1774 }
   1775 
   1776 const char * XMLCALL
   1777 XML_GetInputContext(XML_Parser parser, int *offset, int *size)
   1778 {
   1779 #ifdef XML_CONTEXT_BYTES
   1780   if (eventPtr && buffer) {
   1781     *offset = (int)(eventPtr - buffer);
   1782     *size   = (int)(bufferEnd - buffer);
   1783     return buffer;
   1784   }
   1785 #endif /* defined XML_CONTEXT_BYTES */
   1786   return (char *) 0;
   1787 }
   1788 
   1789 XML_Size XMLCALL
   1790 XML_GetCurrentLineNumber(XML_Parser parser)
   1791 {
   1792   if (eventPtr && eventPtr >= positionPtr) {
   1793     XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
   1794     positionPtr = eventPtr;
   1795   }
   1796   return position.lineNumber + 1;
   1797 }
   1798 
   1799 XML_Size XMLCALL
   1800 XML_GetCurrentColumnNumber(XML_Parser parser)
   1801 {
   1802   if (eventPtr && eventPtr >= positionPtr) {
   1803     XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
   1804     positionPtr = eventPtr;
   1805   }
   1806   return position.columnNumber;
   1807 }
   1808 
   1809 void XMLCALL
   1810 XML_FreeContentModel(XML_Parser parser, XML_Content *model)
   1811 {
   1812   FREE(model);
   1813 }
   1814 
   1815 void * XMLCALL
   1816 XML_MemMalloc(XML_Parser parser, size_t size)
   1817 {
   1818   return MALLOC(size);
   1819 }
   1820 
   1821 void * XMLCALL
   1822 XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)
   1823 {
   1824   return REALLOC(ptr, size);
   1825 }
   1826 
   1827 void XMLCALL
   1828 XML_MemFree(XML_Parser parser, void *ptr)
   1829 {
   1830   FREE(ptr);
   1831 }
   1832 
   1833 void XMLCALL
   1834 XML_DefaultCurrent(XML_Parser parser)
   1835 {
   1836   if (defaultHandler) {
   1837     if (openInternalEntities)
   1838       reportDefault(parser,
   1839                     internalEncoding,
   1840                     openInternalEntities->internalEventPtr,
   1841                     openInternalEntities->internalEventEndPtr);
   1842     else
   1843       reportDefault(parser, encoding, eventPtr, eventEndPtr);
   1844   }
   1845 }
   1846 
   1847 const XML_LChar * XMLCALL
   1848 XML_ErrorString(enum XML_Error code)
   1849 {
   1850   static const XML_LChar* const message[] = {
   1851     0,
   1852     XML_L("out of memory"),
   1853     XML_L("syntax error"),
   1854     XML_L("no element found"),
   1855     XML_L("not well-formed (invalid token)"),
   1856     XML_L("unclosed token"),
   1857     XML_L("partial character"),
   1858     XML_L("mismatched tag"),
   1859     XML_L("duplicate attribute"),
   1860     XML_L("junk after document element"),
   1861     XML_L("illegal parameter entity reference"),
   1862     XML_L("undefined entity"),
   1863     XML_L("recursive entity reference"),
   1864     XML_L("asynchronous entity"),
   1865     XML_L("reference to invalid character number"),
   1866     XML_L("reference to binary entity"),
   1867     XML_L("reference to external entity in attribute"),
   1868     XML_L("XML or text declaration not at start of entity"),
   1869     XML_L("unknown encoding"),
   1870     XML_L("encoding specified in XML declaration is incorrect"),
   1871     XML_L("unclosed CDATA section"),
   1872     XML_L("error in processing external entity reference"),
   1873     XML_L("document is not standalone"),
   1874     XML_L("unexpected parser state - please send a bug report"),
   1875     XML_L("entity declared in parameter entity"),
   1876     XML_L("requested feature requires XML_DTD support in Expat"),
   1877     XML_L("cannot change setting once parsing has begun"),
   1878     XML_L("unbound prefix"),
   1879     XML_L("must not undeclare prefix"),
   1880     XML_L("incomplete markup in parameter entity"),
   1881     XML_L("XML declaration not well-formed"),
   1882     XML_L("text declaration not well-formed"),
   1883     XML_L("illegal character(s) in public id"),
   1884     XML_L("parser suspended"),
   1885     XML_L("parser not suspended"),
   1886     XML_L("parsing aborted"),
   1887     XML_L("parsing finished"),
   1888     XML_L("cannot suspend in external parameter entity"),
   1889     XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),
   1890     XML_L("reserved prefix (xmlns) must not be declared or undeclared"),
   1891     XML_L("prefix must not be bound to one of the reserved namespace names")
   1892   };
   1893   if (code > 0 && code < sizeof(message)/sizeof(message[0]))
   1894     return message[code];
   1895   return NULL;
   1896 }
   1897 
   1898 const XML_LChar * XMLCALL
   1899 XML_ExpatVersion(void) {
   1900 
   1901   /* V1 is used to string-ize the version number. However, it would
   1902      string-ize the actual version macro *names* unless we get them
   1903      substituted before being passed to V1. CPP is defined to expand
   1904      a macro, then rescan for more expansions. Thus, we use V2 to expand
   1905      the version macros, then CPP will expand the resulting V1() macro
   1906      with the correct numerals. */
   1907   /* ### I'm assuming cpp is portable in this respect... */
   1908 
   1909 #define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)
   1910 #define V2(a,b,c) XML_L("expat_")V1(a,b,c)
   1911 
   1912   return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
   1913 
   1914 #undef V1
   1915 #undef V2
   1916 }
   1917 
   1918 XML_Expat_Version XMLCALL
   1919 XML_ExpatVersionInfo(void)
   1920 {
   1921   XML_Expat_Version version;
   1922 
   1923   version.major = XML_MAJOR_VERSION;
   1924   version.minor = XML_MINOR_VERSION;
   1925   version.micro = XML_MICRO_VERSION;
   1926 
   1927   return version;
   1928 }
   1929 
   1930 const XML_Feature * XMLCALL
   1931 XML_GetFeatureList(void)
   1932 {
   1933   static const XML_Feature features[] = {
   1934     {XML_FEATURE_SIZEOF_XML_CHAR,  XML_L("sizeof(XML_Char)"),
   1935      sizeof(XML_Char)},
   1936     {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
   1937      sizeof(XML_LChar)},
   1938 #ifdef XML_UNICODE
   1939     {XML_FEATURE_UNICODE,          XML_L("XML_UNICODE"), 0},
   1940 #endif
   1941 #ifdef XML_UNICODE_WCHAR_T
   1942     {XML_FEATURE_UNICODE_WCHAR_T,  XML_L("XML_UNICODE_WCHAR_T"), 0},
   1943 #endif
   1944 #ifdef XML_DTD
   1945     {XML_FEATURE_DTD,              XML_L("XML_DTD"), 0},
   1946 #endif
   1947 #ifdef XML_CONTEXT_BYTES
   1948     {XML_FEATURE_CONTEXT_BYTES,    XML_L("XML_CONTEXT_BYTES"),
   1949      XML_CONTEXT_BYTES},
   1950 #endif
   1951 #ifdef XML_MIN_SIZE
   1952     {XML_FEATURE_MIN_SIZE,         XML_L("XML_MIN_SIZE"), 0},
   1953 #endif
   1954 #ifdef XML_NS
   1955     {XML_FEATURE_NS,               XML_L("XML_NS"), 0},
   1956 #endif
   1957 #ifdef XML_LARGE_SIZE
   1958     {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
   1959 #endif
   1960     {XML_FEATURE_END,              NULL, 0}
   1961   };
   1962 
   1963   return features;
   1964 }
   1965 
   1966 /* Initially tag->rawName always points into the parse buffer;
   1967    for those TAG instances opened while the current parse buffer was
   1968    processed, and not yet closed, we need to store tag->rawName in a more
   1969    permanent location, since the parse buffer is about to be discarded.
   1970 */
   1971 static XML_Bool
   1972 storeRawNames(XML_Parser parser)
   1973 {
   1974   TAG *tag = tagStack;
   1975   while (tag) {
   1976     int bufSize;
   1977     int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
   1978     char *rawNameBuf = tag->buf + nameLen;
   1979     /* Stop if already stored.  Since tagStack is a stack, we can stop
   1980        at the first entry that has already been copied; everything
   1981        below it in the stack is already been accounted for in a
   1982        previous call to this function.
   1983     */
   1984     if (tag->rawName == rawNameBuf)
   1985       break;
   1986     /* For re-use purposes we need to ensure that the
   1987        size of tag->buf is a multiple of sizeof(XML_Char).
   1988     */
   1989     bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
   1990     if (bufSize > tag->bufEnd - tag->buf) {
   1991       char *temp = (char *)REALLOC(tag->buf, bufSize);
   1992       if (temp == NULL)
   1993         return XML_FALSE;
   1994       /* if tag->name.str points to tag->buf (only when namespace
   1995          processing is off) then we have to update it
   1996       */
   1997       if (tag->name.str == (XML_Char *)tag->buf)
   1998         tag->name.str = (XML_Char *)temp;
   1999       /* if tag->name.localPart is set (when namespace processing is on)
   2000          then update it as well, since it will always point into tag->buf
   2001       */
   2002       if (tag->name.localPart)
   2003         tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -
   2004                                                   (XML_Char *)tag->buf);
   2005       tag->buf = temp;
   2006       tag->bufEnd = temp + bufSize;
   2007       rawNameBuf = temp + nameLen;
   2008     }
   2009     memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
   2010     tag->rawName = rawNameBuf;
   2011     tag = tag->parent;
   2012   }
   2013   return XML_TRUE;
   2014 }
   2015 
   2016 static enum XML_Error PTRCALL
   2017 contentProcessor(XML_Parser parser,
   2018                  const char *start,
   2019                  const char *end,
   2020                  const char **endPtr)
   2021 {
   2022   enum XML_Error result = doContent(parser, 0, encoding, start, end,
   2023                                     endPtr, (XML_Bool)!ps_finalBuffer);
   2024   if (result == XML_ERROR_NONE) {
   2025     if (!storeRawNames(parser))
   2026       return XML_ERROR_NO_MEMORY;
   2027   }
   2028   return result;
   2029 }
   2030 
   2031 static enum XML_Error PTRCALL
   2032 externalEntityInitProcessor(XML_Parser parser,
   2033                             const char *start,
   2034                             const char *end,
   2035                             const char **endPtr)
   2036 {
   2037   enum XML_Error result = initializeEncoding(parser);
   2038   if (result != XML_ERROR_NONE)
   2039     return result;
   2040   processor = externalEntityInitProcessor2;
   2041   return externalEntityInitProcessor2(parser, start, end, endPtr);
   2042 }
   2043 
   2044 static enum XML_Error PTRCALL
   2045 externalEntityInitProcessor2(XML_Parser parser,
   2046                              const char *start,
   2047                              const char *end,
   2048                              const char **endPtr)
   2049 {
   2050   const char *next = start; /* XmlContentTok doesn't always set the last arg */
   2051   int tok = XmlContentTok(encoding, start, end, &next);
   2052   switch (tok) {
   2053   case XML_TOK_BOM:
   2054     /* If we are at the end of the buffer, this would cause the next stage,
   2055        i.e. externalEntityInitProcessor3, to pass control directly to
   2056        doContent (by detecting XML_TOK_NONE) without processing any xml text
   2057        declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
   2058     */
   2059     if (next == end && !ps_finalBuffer) {
   2060       *endPtr = next;
   2061       return XML_ERROR_NONE;
   2062     }
   2063     start = next;
   2064     break;
   2065   case XML_TOK_PARTIAL:
   2066     if (!ps_finalBuffer) {
   2067       *endPtr = start;
   2068       return XML_ERROR_NONE;
   2069     }
   2070     eventPtr = start;
   2071     return XML_ERROR_UNCLOSED_TOKEN;
   2072   case XML_TOK_PARTIAL_CHAR:
   2073     if (!ps_finalBuffer) {
   2074       *endPtr = start;
   2075       return XML_ERROR_NONE;
   2076     }
   2077     eventPtr = start;
   2078     return XML_ERROR_PARTIAL_CHAR;
   2079   }
   2080   processor = externalEntityInitProcessor3;
   2081   return externalEntityInitProcessor3(parser, start, end, endPtr);
   2082 }
   2083 
   2084 static enum XML_Error PTRCALL
   2085 externalEntityInitProcessor3(XML_Parser parser,
   2086                              const char *start,
   2087                              const char *end,
   2088                              const char **endPtr)
   2089 {
   2090   int tok;
   2091   const char *next = start; /* XmlContentTok doesn't always set the last arg */
   2092   eventPtr = start;
   2093   tok = XmlContentTok(encoding, start, end, &next);
   2094   eventEndPtr = next;
   2095 
   2096   switch (tok) {
   2097   case XML_TOK_XML_DECL:
   2098     {
   2099       enum XML_Error result;
   2100       result = processXmlDecl(parser, 1, start, next);
   2101       if (result != XML_ERROR_NONE)
   2102         return result;
   2103       switch (ps_parsing) {
   2104       case XML_SUSPENDED:
   2105         *endPtr = next;
   2106         return XML_ERROR_NONE;
   2107       case XML_FINISHED:
   2108         return XML_ERROR_ABORTED;
   2109       default:
   2110         start = next;
   2111       }
   2112     }
   2113     break;
   2114   case XML_TOK_PARTIAL:
   2115     if (!ps_finalBuffer) {
   2116       *endPtr = start;
   2117       return XML_ERROR_NONE;
   2118     }
   2119     return XML_ERROR_UNCLOSED_TOKEN;
   2120   case XML_TOK_PARTIAL_CHAR:
   2121     if (!ps_finalBuffer) {
   2122       *endPtr = start;
   2123       return XML_ERROR_NONE;
   2124     }
   2125     return XML_ERROR_PARTIAL_CHAR;
   2126   }
   2127   processor = externalEntityContentProcessor;
   2128   tagLevel = 1;
   2129   return externalEntityContentProcessor(parser, start, end, endPtr);
   2130 }
   2131 
   2132 static enum XML_Error PTRCALL
   2133 externalEntityContentProcessor(XML_Parser parser,
   2134                                const char *start,
   2135                                const char *end,
   2136                                const char **endPtr)
   2137 {
   2138   enum XML_Error result = doContent(parser, 1, encoding, start, end,
   2139                                     endPtr, (XML_Bool)!ps_finalBuffer);
   2140   if (result == XML_ERROR_NONE) {
   2141     if (!storeRawNames(parser))
   2142       return XML_ERROR_NO_MEMORY;
   2143   }
   2144   return result;
   2145 }
   2146 
   2147 static enum XML_Error
   2148 doContent(XML_Parser parser,
   2149           int startTagLevel,
   2150           const ENCODING *enc,
   2151           const char *s,
   2152           const char *end,
   2153           const char **nextPtr,
   2154           XML_Bool haveMore)
   2155 {
   2156   /* save one level of indirection */
   2157   DTD * const dtd = _dtd;
   2158 
   2159   const char **eventPP;
   2160   const char **eventEndPP;
   2161   if (enc == encoding) {
   2162     eventPP = &eventPtr;
   2163     eventEndPP = &eventEndPtr;
   2164   }
   2165   else {
   2166     eventPP = &(openInternalEntities->internalEventPtr);
   2167     eventEndPP = &(openInternalEntities->internalEventEndPtr);
   2168   }
   2169   *eventPP = s;
   2170 
   2171   for (;;) {
   2172     const char *next = s; /* XmlContentTok doesn't always set the last arg */
   2173     int tok = XmlContentTok(enc, s, end, &next);
   2174     *eventEndPP = next;
   2175     switch (tok) {
   2176     case XML_TOK_TRAILING_CR:
   2177       if (haveMore) {
   2178         *nextPtr = s;
   2179         return XML_ERROR_NONE;
   2180       }
   2181       *eventEndPP = end;
   2182       if (characterDataHandler) {
   2183         XML_Char c = 0xA;
   2184         characterDataHandler(handlerArg, &c, 1);
   2185       }
   2186       else if (defaultHandler)
   2187         reportDefault(parser, enc, s, end);
   2188       /* We are at the end of the final buffer, should we check for
   2189          XML_SUSPENDED, XML_FINISHED?
   2190       */
   2191       if (startTagLevel == 0)
   2192         return XML_ERROR_NO_ELEMENTS;
   2193       if (tagLevel != startTagLevel)
   2194         return XML_ERROR_ASYNC_ENTITY;
   2195       *nextPtr = end;
   2196       return XML_ERROR_NONE;
   2197     case XML_TOK_NONE:
   2198       if (haveMore) {
   2199         *nextPtr = s;
   2200         return XML_ERROR_NONE;
   2201       }
   2202       if (startTagLevel > 0) {
   2203         if (tagLevel != startTagLevel)
   2204           return XML_ERROR_ASYNC_ENTITY;
   2205         *nextPtr = s;
   2206         return XML_ERROR_NONE;
   2207       }
   2208       return XML_ERROR_NO_ELEMENTS;
   2209     case XML_TOK_INVALID:
   2210       *eventPP = next;
   2211       return XML_ERROR_INVALID_TOKEN;
   2212     case XML_TOK_PARTIAL:
   2213       if (haveMore) {
   2214         *nextPtr = s;
   2215         return XML_ERROR_NONE;
   2216       }
   2217       return XML_ERROR_UNCLOSED_TOKEN;
   2218     case XML_TOK_PARTIAL_CHAR:
   2219       if (haveMore) {
   2220         *nextPtr = s;
   2221         return XML_ERROR_NONE;
   2222       }
   2223       return XML_ERROR_PARTIAL_CHAR;
   2224     case XML_TOK_ENTITY_REF:
   2225       {
   2226         const XML_Char *name;
   2227         ENTITY *entity;
   2228         XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
   2229                                               s + enc->minBytesPerChar,
   2230                                               next - enc->minBytesPerChar);
   2231         if (ch) {
   2232           if (characterDataHandler)
   2233             characterDataHandler(handlerArg, &ch, 1);
   2234           else if (defaultHandler)
   2235             reportDefault(parser, enc, s, next);
   2236           break;
   2237         }
   2238         name = poolStoreString(&dtd->pool, enc,
   2239                                 s + enc->minBytesPerChar,
   2240                                 next - enc->minBytesPerChar);
   2241         if (!name)
   2242           return XML_ERROR_NO_MEMORY;
   2243         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
   2244         poolDiscard(&dtd->pool);
   2245         /* First, determine if a check for an existing declaration is needed;
   2246            if yes, check that the entity exists, and that it is internal,
   2247            otherwise call the skipped entity or default handler.
   2248         */
   2249         if (!dtd->hasParamEntityRefs || dtd->standalone) {
   2250           if (!entity)
   2251             return XML_ERROR_UNDEFINED_ENTITY;
   2252           else if (!entity->is_internal)
   2253             return XML_ERROR_ENTITY_DECLARED_IN_PE;
   2254         }
   2255         else if (!entity) {
   2256           if (skippedEntityHandler)
   2257             skippedEntityHandler(handlerArg, name, 0);
   2258           else if (defaultHandler)
   2259             reportDefault(parser, enc, s, next);
   2260           break;
   2261         }
   2262         if (entity->open)
   2263           return XML_ERROR_RECURSIVE_ENTITY_REF;
   2264         if (entity->notation)
   2265           return XML_ERROR_BINARY_ENTITY_REF;
   2266         if (entity->textPtr) {
   2267           enum XML_Error result;
   2268           if (!defaultExpandInternalEntities) {
   2269             if (skippedEntityHandler)
   2270               skippedEntityHandler(handlerArg, entity->name, 0);
   2271             else if (defaultHandler)
   2272               reportDefault(parser, enc, s, next);
   2273             break;
   2274           }
   2275           result = processInternalEntity(parser, entity, XML_FALSE);
   2276           if (result != XML_ERROR_NONE)
   2277             return result;
   2278         }
   2279         else if (externalEntityRefHandler) {
   2280           const XML_Char *context;
   2281           entity->open = XML_TRUE;
   2282           context = getContext(parser);
   2283           entity->open = XML_FALSE;
   2284           if (!context)
   2285             return XML_ERROR_NO_MEMORY;
   2286           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
   2287                                         context,
   2288                                         entity->base,
   2289                                         entity->systemId,
   2290                                         entity->publicId))
   2291             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
   2292           poolDiscard(&tempPool);
   2293         }
   2294         else if (defaultHandler)
   2295           reportDefault(parser, enc, s, next);
   2296         break;
   2297       }
   2298     case XML_TOK_START_TAG_NO_ATTS:
   2299       /* fall through */
   2300     case XML_TOK_START_TAG_WITH_ATTS:
   2301       {
   2302         TAG *tag;
   2303         enum XML_Error result;
   2304         XML_Char *toPtr;
   2305         if (freeTagList) {
   2306           tag = freeTagList;
   2307           freeTagList = freeTagList->parent;
   2308         }
   2309         else {
   2310           tag = (TAG *)MALLOC(sizeof(TAG));
   2311           if (!tag)
   2312             return XML_ERROR_NO_MEMORY;
   2313           tag->buf = (char *)MALLOC(INIT_TAG_BUF_SIZE);
   2314           if (!tag->buf) {
   2315             FREE(tag);
   2316             return XML_ERROR_NO_MEMORY;
   2317           }
   2318           tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
   2319         }
   2320         tag->bindings = NULL;
   2321         tag->parent = tagStack;
   2322         tagStack = tag;
   2323         tag->name.localPart = NULL;
   2324         tag->name.prefix = NULL;
   2325         tag->rawName = s + enc->minBytesPerChar;
   2326         tag->rawNameLength = XmlNameLength(enc, tag->rawName);
   2327         ++tagLevel;
   2328         {
   2329           const char *rawNameEnd = tag->rawName + tag->rawNameLength;
   2330           const char *fromPtr = tag->rawName;
   2331           toPtr = (XML_Char *)tag->buf;
   2332           for (;;) {
   2333             int bufSize;
   2334             int convLen;
   2335             XmlConvert(enc,
   2336                        &fromPtr, rawNameEnd,
   2337                        (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
   2338             convLen = (int)(toPtr - (XML_Char *)tag->buf);
   2339             if (fromPtr == rawNameEnd) {
   2340               tag->name.strLen = convLen;
   2341               break;
   2342             }
   2343             bufSize = (int)(tag->bufEnd - tag->buf) << 1;
   2344             {
   2345               char *temp = (char *)REALLOC(tag->buf, bufSize);
   2346               if (temp == NULL)
   2347                 return XML_ERROR_NO_MEMORY;
   2348               tag->buf = temp;
   2349               tag->bufEnd = temp + bufSize;
   2350               toPtr = (XML_Char *)temp + convLen;
   2351             }
   2352           }
   2353         }
   2354         tag->name.str = (XML_Char *)tag->buf;
   2355         *toPtr = XML_T('\0');
   2356         result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
   2357         if (result)
   2358           return result;
   2359         if (startElementHandler)
   2360           startElementHandler(handlerArg, tag->name.str,
   2361                               (const XML_Char **)atts);
   2362         else if (defaultHandler)
   2363           reportDefault(parser, enc, s, next);
   2364         poolClear(&tempPool);
   2365         break;
   2366       }
   2367     case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
   2368       /* fall through */
   2369     case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
   2370       {
   2371         const char *rawName = s + enc->minBytesPerChar;
   2372         enum XML_Error result;
   2373         BINDING *bindings = NULL;
   2374         XML_Bool noElmHandlers = XML_TRUE;
   2375         TAG_NAME name;
   2376         name.str = poolStoreString(&tempPool, enc, rawName,
   2377                                    rawName + XmlNameLength(enc, rawName));
   2378         if (!name.str)
   2379           return XML_ERROR_NO_MEMORY;
   2380         poolFinish(&tempPool);
   2381         result = storeAtts(parser, enc, s, &name, &bindings);
   2382         if (result)
   2383           return result;
   2384         poolFinish(&tempPool);
   2385         if (startElementHandler) {
   2386           startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
   2387           noElmHandlers = XML_FALSE;
   2388         }
   2389         if (endElementHandler) {
   2390           if (startElementHandler)
   2391             *eventPP = *eventEndPP;
   2392           endElementHandler(handlerArg, name.str);
   2393           noElmHandlers = XML_FALSE;
   2394         }
   2395         if (noElmHandlers && defaultHandler)
   2396           reportDefault(parser, enc, s, next);
   2397         poolClear(&tempPool);
   2398         while (bindings) {
   2399           BINDING *b = bindings;
   2400           if (endNamespaceDeclHandler)
   2401             endNamespaceDeclHandler(handlerArg, b->prefix->name);
   2402           bindings = bindings->nextTagBinding;
   2403           b->nextTagBinding = freeBindingList;
   2404           freeBindingList = b;
   2405           b->prefix->binding = b->prevPrefixBinding;
   2406         }
   2407       }
   2408       if (tagLevel == 0)
   2409         return epilogProcessor(parser, next, end, nextPtr);
   2410       break;
   2411     case XML_TOK_END_TAG:
   2412       if (tagLevel == startTagLevel)
   2413         return XML_ERROR_ASYNC_ENTITY;
   2414       else {
   2415         int len;
   2416         const char *rawName;
   2417         TAG *tag = tagStack;
   2418         tagStack = tag->parent;
   2419         tag->parent = freeTagList;
   2420         freeTagList = tag;
   2421         rawName = s + enc->minBytesPerChar*2;
   2422         len = XmlNameLength(enc, rawName);
   2423         if (len != tag->rawNameLength
   2424             || memcmp(tag->rawName, rawName, len) != 0) {
   2425           *eventPP = rawName;
   2426           return XML_ERROR_TAG_MISMATCH;
   2427         }
   2428         --tagLevel;
   2429         if (endElementHandler) {
   2430           const XML_Char *localPart;
   2431           const XML_Char *prefix;
   2432           XML_Char *uri;
   2433           localPart = tag->name.localPart;
   2434           if (ns && localPart) {
   2435             /* localPart and prefix may have been overwritten in
   2436                tag->name.str, since this points to the binding->uri
   2437                buffer which gets re-used; so we have to add them again
   2438             */
   2439             uri = (XML_Char *)tag->name.str + tag->name.uriLen;
   2440             /* don't need to check for space - already done in storeAtts() */
   2441             while (*localPart) *uri++ = *localPart++;
   2442             prefix = (XML_Char *)tag->name.prefix;
   2443             if (ns_triplets && prefix) {
   2444               *uri++ = namespaceSeparator;
   2445               while (*prefix) *uri++ = *prefix++;
   2446              }
   2447             *uri = XML_T('\0');
   2448           }
   2449           endElementHandler(handlerArg, tag->name.str);
   2450         }
   2451         else if (defaultHandler)
   2452           reportDefault(parser, enc, s, next);
   2453         while (tag->bindings) {
   2454           BINDING *b = tag->bindings;
   2455           if (endNamespaceDeclHandler)
   2456             endNamespaceDeclHandler(handlerArg, b->prefix->name);
   2457           tag->bindings = tag->bindings->nextTagBinding;
   2458           b->nextTagBinding = freeBindingList;
   2459           freeBindingList = b;
   2460           b->prefix->binding = b->prevPrefixBinding;
   2461         }
   2462         if (tagLevel == 0)
   2463           return epilogProcessor(parser, next, end, nextPtr);
   2464       }
   2465       break;
   2466     case XML_TOK_CHAR_REF:
   2467       {
   2468         int n = XmlCharRefNumber(enc, s);
   2469         if (n < 0)
   2470           return XML_ERROR_BAD_CHAR_REF;
   2471         if (characterDataHandler) {
   2472           XML_Char buf[XML_ENCODE_MAX];
   2473           characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
   2474         }
   2475         else if (defaultHandler)
   2476           reportDefault(parser, enc, s, next);
   2477       }
   2478       break;
   2479     case XML_TOK_XML_DECL:
   2480       return XML_ERROR_MISPLACED_XML_PI;
   2481     case XML_TOK_DATA_NEWLINE:
   2482       if (characterDataHandler) {
   2483         XML_Char c = 0xA;
   2484         characterDataHandler(handlerArg, &c, 1);
   2485       }
   2486       else if (defaultHandler)
   2487         reportDefault(parser, enc, s, next);
   2488       break;
   2489     case XML_TOK_CDATA_SECT_OPEN:
   2490       {
   2491         enum XML_Error result;
   2492         if (startCdataSectionHandler)
   2493           startCdataSectionHandler(handlerArg);
   2494 #if 0
   2495         /* Suppose you doing a transformation on a document that involves
   2496            changing only the character data.  You set up a defaultHandler
   2497            and a characterDataHandler.  The defaultHandler simply copies
   2498            characters through.  The characterDataHandler does the
   2499            transformation and writes the characters out escaping them as
   2500            necessary.  This case will fail to work if we leave out the
   2501            following two lines (because & and < inside CDATA sections will
   2502            be incorrectly escaped).
   2503 
   2504            However, now we have a start/endCdataSectionHandler, so it seems
   2505            easier to let the user deal with this.
   2506         */
   2507         else if (characterDataHandler)
   2508           characterDataHandler(handlerArg, dataBuf, 0);
   2509 #endif
   2510         else if (defaultHandler)
   2511           reportDefault(parser, enc, s, next);
   2512         result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
   2513         if (result != XML_ERROR_NONE)
   2514           return result;
   2515         else if (!next) {
   2516           processor = cdataSectionProcessor;
   2517           return result;
   2518         }
   2519       }
   2520       break;
   2521     case XML_TOK_TRAILING_RSQB:
   2522       if (haveMore) {
   2523         *nextPtr = s;
   2524         return XML_ERROR_NONE;
   2525       }
   2526       if (characterDataHandler) {
   2527         if (MUST_CONVERT(enc, s)) {
   2528           ICHAR *dataPtr = (ICHAR *)dataBuf;
   2529           XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
   2530           characterDataHandler(handlerArg, dataBuf,
   2531                                (int)(dataPtr - (ICHAR *)dataBuf));
   2532         }
   2533         else
   2534           characterDataHandler(handlerArg,
   2535                                (XML_Char *)s,
   2536                                (int)((XML_Char *)end - (XML_Char *)s));
   2537       }
   2538       else if (defaultHandler)
   2539         reportDefault(parser, enc, s, end);
   2540       /* We are at the end of the final buffer, should we check for
   2541          XML_SUSPENDED, XML_FINISHED?
   2542       */
   2543       if (startTagLevel == 0) {
   2544         *eventPP = end;
   2545         return XML_ERROR_NO_ELEMENTS;
   2546       }
   2547       if (tagLevel != startTagLevel) {
   2548         *eventPP = end;
   2549         return XML_ERROR_ASYNC_ENTITY;
   2550       }
   2551       *nextPtr = end;
   2552       return XML_ERROR_NONE;
   2553     case XML_TOK_DATA_CHARS:
   2554       {
   2555         XML_CharacterDataHandler charDataHandler = characterDataHandler;
   2556         if (charDataHandler) {
   2557           if (MUST_CONVERT(enc, s)) {
   2558             for (;;) {
   2559               ICHAR *dataPtr = (ICHAR *)dataBuf;
   2560               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
   2561               *eventEndPP = s;
   2562               charDataHandler(handlerArg, dataBuf,
   2563                               (int)(dataPtr - (ICHAR *)dataBuf));
   2564               if (s == next)
   2565                 break;
   2566               *eventPP = s;
   2567             }
   2568           }
   2569           else
   2570             charDataHandler(handlerArg,
   2571                             (XML_Char *)s,
   2572                             (int)((XML_Char *)next - (XML_Char *)s));
   2573         }
   2574         else if (defaultHandler)
   2575           reportDefault(parser, enc, s, next);
   2576       }
   2577       break;
   2578     case XML_TOK_PI:
   2579       if (!reportProcessingInstruction(parser, enc, s, next))
   2580         return XML_ERROR_NO_MEMORY;
   2581       break;
   2582     case XML_TOK_COMMENT:
   2583       if (!reportComment(parser, enc, s, next))
   2584         return XML_ERROR_NO_MEMORY;
   2585       break;
   2586     default:
   2587       if (defaultHandler)
   2588         reportDefault(parser, enc, s, next);
   2589       break;
   2590     }
   2591     *eventPP = s = next;
   2592     switch (ps_parsing) {
   2593     case XML_SUSPENDED:
   2594       *nextPtr = next;
   2595       return XML_ERROR_NONE;
   2596     case XML_FINISHED:
   2597       return XML_ERROR_ABORTED;
   2598     default: ;
   2599     }
   2600   }
   2601   /* not reached */
   2602 }
   2603 
   2604 /* Precondition: all arguments must be non-NULL;
   2605    Purpose:
   2606    - normalize attributes
   2607    - check attributes for well-formedness
   2608    - generate namespace aware attribute names (URI, prefix)
   2609    - build list of attributes for startElementHandler
   2610    - default attributes
   2611    - process namespace declarations (check and report them)
   2612    - generate namespace aware element name (URI, prefix)
   2613 */
   2614 static enum XML_Error
   2615 storeAtts(XML_Parser parser, const ENCODING *enc,
   2616           const char *attStr, TAG_NAME *tagNamePtr,
   2617           BINDING **bindingsPtr)
   2618 {
   2619   DTD * const dtd = _dtd;  /* save one level of indirection */
   2620   ELEMENT_TYPE *elementType;
   2621   int nDefaultAtts;
   2622   const XML_Char **appAtts;   /* the attribute list for the application */
   2623   int attIndex = 0;
   2624   int prefixLen;
   2625   int i;
   2626   int n;
   2627   XML_Char *uri;
   2628   int nPrefixes = 0;
   2629   BINDING *binding;
   2630   const XML_Char *localPart;
   2631 
   2632   /* lookup the element type name */
   2633   elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);
   2634   if (!elementType) {
   2635     const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
   2636     if (!name)
   2637       return XML_ERROR_NO_MEMORY;
   2638     elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,
   2639                                          sizeof(ELEMENT_TYPE));
   2640     if (!elementType)
   2641       return XML_ERROR_NO_MEMORY;
   2642     if (ns && !setElementTypePrefix(parser, elementType))
   2643       return XML_ERROR_NO_MEMORY;
   2644   }
   2645   nDefaultAtts = elementType->nDefaultAtts;
   2646 
   2647   /* get the attributes from the tokenizer */
   2648   n = XmlGetAttributes(enc, attStr, attsSize, atts);
   2649   if (n + nDefaultAtts > attsSize) {
   2650     int oldAttsSize = attsSize;
   2651     ATTRIBUTE *temp;
   2652     attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
   2653     temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
   2654     if (temp == NULL)
   2655       return XML_ERROR_NO_MEMORY;
   2656     atts = temp;
   2657     if (n > oldAttsSize)
   2658       XmlGetAttributes(enc, attStr, n, atts);
   2659   }
   2660 
   2661   appAtts = (const XML_Char **)atts;
   2662   for (i = 0; i < n; i++) {
   2663     /* add the name and value to the attribute list */
   2664     ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
   2665                                          atts[i].name
   2666                                          + XmlNameLength(enc, atts[i].name));
   2667     if (!attId)
   2668       return XML_ERROR_NO_MEMORY;
   2669     /* Detect duplicate attributes by their QNames. This does not work when
   2670        namespace processing is turned on and different prefixes for the same
   2671        namespace are used. For this case we have a check further down.
   2672     */
   2673     if ((attId->name)[-1]) {
   2674       if (enc == encoding)
   2675         eventPtr = atts[i].name;
   2676       return XML_ERROR_DUPLICATE_ATTRIBUTE;
   2677     }
   2678     (attId->name)[-1] = 1;
   2679     appAtts[attIndex++] = attId->name;
   2680     if (!atts[i].normalized) {
   2681       enum XML_Error result;
   2682       XML_Bool isCdata = XML_TRUE;
   2683 
   2684       /* figure out whether declared as other than CDATA */
   2685       if (attId->maybeTokenized) {
   2686         int j;
   2687         for (j = 0; j < nDefaultAtts; j++) {
   2688           if (attId == elementType->defaultAtts[j].id) {
   2689             isCdata = elementType->defaultAtts[j].isCdata;
   2690             break;
   2691           }
   2692         }
   2693       }
   2694 
   2695       /* normalize the attribute value */
   2696       result = storeAttributeValue(parser, enc, isCdata,
   2697                                    atts[i].valuePtr, atts[i].valueEnd,
   2698                                    &tempPool);
   2699       if (result)
   2700         return result;
   2701       appAtts[attIndex] = poolStart(&tempPool);
   2702       poolFinish(&tempPool);
   2703     }
   2704     else {
   2705       /* the value did not need normalizing */
   2706       appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,
   2707                                           atts[i].valueEnd);
   2708       if (appAtts[attIndex] == 0)
   2709         return XML_ERROR_NO_MEMORY;
   2710       poolFinish(&tempPool);
   2711     }
   2712     /* handle prefixed attribute names */
   2713     if (attId->prefix) {
   2714       if (attId->xmlns) {
   2715         /* deal with namespace declarations here */
   2716         enum XML_Error result = addBinding(parser, attId->prefix, attId,
   2717                                            appAtts[attIndex], bindingsPtr);
   2718         if (result)
   2719           return result;
   2720         --attIndex;
   2721       }
   2722       else {
   2723         /* deal with other prefixed names later */
   2724         attIndex++;
   2725         nPrefixes++;
   2726         (attId->name)[-1] = 2;
   2727       }
   2728     }
   2729     else
   2730       attIndex++;
   2731   }
   2732 
   2733   /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
   2734   nSpecifiedAtts = attIndex;
   2735   if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
   2736     for (i = 0; i < attIndex; i += 2)
   2737       if (appAtts[i] == elementType->idAtt->name) {
   2738         idAttIndex = i;
   2739         break;
   2740       }
   2741   }
   2742   else
   2743     idAttIndex = -1;
   2744 
   2745   /* do attribute defaulting */
   2746   for (i = 0; i < nDefaultAtts; i++) {
   2747     const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
   2748     if (!(da->id->name)[-1] && da->value) {
   2749       if (da->id->prefix) {
   2750         if (da->id->xmlns) {
   2751           enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
   2752                                              da->value, bindingsPtr);
   2753           if (result)
   2754             return result;
   2755         }
   2756         else {
   2757           (da->id->name)[-1] = 2;
   2758           nPrefixes++;
   2759           appAtts[attIndex++] = da->id->name;
   2760           appAtts[attIndex++] = da->value;
   2761         }
   2762       }
   2763       else {
   2764         (da->id->name)[-1] = 1;
   2765         appAtts[attIndex++] = da->id->name;
   2766         appAtts[attIndex++] = da->value;
   2767       }
   2768     }
   2769   }
   2770   appAtts[attIndex] = 0;
   2771 
   2772   /* expand prefixed attribute names, check for duplicates,
   2773      and clear flags that say whether attributes were specified */
   2774   i = 0;
   2775   if (nPrefixes) {
   2776     int j;  /* hash table index */
   2777     unsigned long version = nsAttsVersion;
   2778     int nsAttsSize = (int)1 << nsAttsPower;
   2779     /* size of hash table must be at least 2 * (# of prefixed attributes) */
   2780     if ((nPrefixes << 1) >> nsAttsPower) {  /* true for nsAttsPower = 0 */
   2781       NS_ATT *temp;
   2782       /* hash table size must also be a power of 2 and >= 8 */
   2783       while (nPrefixes >> nsAttsPower++);
   2784       if (nsAttsPower < 3)
   2785         nsAttsPower = 3;
   2786       nsAttsSize = (int)1 << nsAttsPower;
   2787       temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));
   2788       if (!temp)
   2789         return XML_ERROR_NO_MEMORY;
   2790       nsAtts = temp;
   2791       version = 0;  /* force re-initialization of nsAtts hash table */
   2792     }
   2793     /* using a version flag saves us from initializing nsAtts every time */
   2794     if (!version) {  /* initialize version flags when version wraps around */
   2795       version = INIT_ATTS_VERSION;
   2796       for (j = nsAttsSize; j != 0; )
   2797         nsAtts[--j].version = version;
   2798     }
   2799     nsAttsVersion = --version;
   2800 
   2801     /* expand prefixed names and check for duplicates */
   2802     for (; i < attIndex; i += 2) {
   2803       const XML_Char *s = appAtts[i];
   2804       if (s[-1] == 2) {  /* prefixed */
   2805         ATTRIBUTE_ID *id;
   2806         const BINDING *b;
   2807         unsigned long uriHash = 0;
   2808         ((XML_Char *)s)[-1] = 0;  /* clear flag */
   2809         id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);
   2810         b = id->prefix->binding;
   2811         if (!b)
   2812           return XML_ERROR_UNBOUND_PREFIX;
   2813 
   2814         /* as we expand the name we also calculate its hash value */
   2815         for (j = 0; j < b->uriLen; j++) {
   2816           const XML_Char c = b->uri[j];
   2817           if (!poolAppendChar(&tempPool, c))
   2818             return XML_ERROR_NO_MEMORY;
   2819           uriHash = CHAR_HASH(uriHash, c);
   2820         }
   2821         while (*s++ != XML_T(ASCII_COLON))
   2822           ;
   2823         do {  /* copies null terminator */
   2824           const XML_Char c = *s;
   2825           if (!poolAppendChar(&tempPool, *s))
   2826             return XML_ERROR_NO_MEMORY;
   2827           uriHash = CHAR_HASH(uriHash, c);
   2828         } while (*s++);
   2829 
   2830         { /* Check hash table for duplicate of expanded name (uriName).
   2831              Derived from code in lookup(HASH_TABLE *table, ...).
   2832           */
   2833           unsigned char step = 0;
   2834           unsigned long mask = nsAttsSize - 1;
   2835           j = uriHash & mask;  /* index into hash table */
   2836           while (nsAtts[j].version == version) {
   2837             /* for speed we compare stored hash values first */
   2838             if (uriHash == nsAtts[j].hash) {
   2839               const XML_Char *s1 = poolStart(&tempPool);
   2840               const XML_Char *s2 = nsAtts[j].uriName;
   2841               /* s1 is null terminated, but not s2 */
   2842               for (; *s1 == *s2 && *s1 != 0; s1++, s2++);
   2843               if (*s1 == 0)
   2844                 return XML_ERROR_DUPLICATE_ATTRIBUTE;
   2845             }
   2846             if (!step)
   2847               step = PROBE_STEP(uriHash, mask, nsAttsPower);
   2848             j < step ? (j += nsAttsSize - step) : (j -= step);
   2849           }
   2850         }
   2851 
   2852         if (ns_triplets) {  /* append namespace separator and prefix */
   2853           tempPool.ptr[-1] = namespaceSeparator;
   2854           s = b->prefix->name;
   2855           do {
   2856             if (!poolAppendChar(&tempPool, *s))
   2857               return XML_ERROR_NO_MEMORY;
   2858           } while (*s++);
   2859         }
   2860 
   2861         /* store expanded name in attribute list */
   2862         s = poolStart(&tempPool);
   2863         poolFinish(&tempPool);
   2864         appAtts[i] = s;
   2865 
   2866         /* fill empty slot with new version, uriName and hash value */
   2867         nsAtts[j].version = version;
   2868         nsAtts[j].hash = uriHash;
   2869         nsAtts[j].uriName = s;
   2870 
   2871         if (!--nPrefixes) {
   2872           i += 2;
   2873           break;
   2874         }
   2875       }
   2876       else  /* not prefixed */
   2877         ((XML_Char *)s)[-1] = 0;  /* clear flag */
   2878     }
   2879   }
   2880   /* clear flags for the remaining attributes */
   2881   for (; i < attIndex; i += 2)
   2882     ((XML_Char *)(appAtts[i]))[-1] = 0;
   2883   for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
   2884     binding->attId->name[-1] = 0;
   2885 
   2886   if (!ns)
   2887     return XML_ERROR_NONE;
   2888 
   2889   /* expand the element type name */
   2890   if (elementType->prefix) {
   2891     binding = elementType->prefix->binding;
   2892     if (!binding)
   2893       return XML_ERROR_UNBOUND_PREFIX;
   2894     localPart = tagNamePtr->str;
   2895     while (*localPart++ != XML_T(ASCII_COLON))
   2896       ;
   2897   }
   2898   else if (dtd->defaultPrefix.binding) {
   2899     binding = dtd->defaultPrefix.binding;
   2900     localPart = tagNamePtr->str;
   2901   }
   2902   else
   2903     return XML_ERROR_NONE;
   2904   prefixLen = 0;
   2905   if (ns_triplets && binding->prefix->name) {
   2906     for (; binding->prefix->name[prefixLen++];)
   2907       ;  /* prefixLen includes null terminator */
   2908   }
   2909   tagNamePtr->localPart = localPart;
   2910   tagNamePtr->uriLen = binding->uriLen;
   2911   tagNamePtr->prefix = binding->prefix->name;
   2912   tagNamePtr->prefixLen = prefixLen;
   2913   for (i = 0; localPart[i++];)
   2914     ;  /* i includes null terminator */
   2915   n = i + binding->uriLen + prefixLen;
   2916   if (n > binding->uriAlloc) {
   2917     TAG *p;
   2918     uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
   2919     if (!uri)
   2920       return XML_ERROR_NO_MEMORY;
   2921     binding->uriAlloc = n + EXPAND_SPARE;
   2922     memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
   2923     for (p = tagStack; p; p = p->parent)
   2924       if (p->name.str == binding->uri)
   2925         p->name.str = uri;
   2926     FREE(binding->uri);
   2927     binding->uri = uri;
   2928   }
   2929   /* if namespaceSeparator != '\0' then uri includes it already */
   2930   uri = binding->uri + binding->uriLen;
   2931   memcpy(uri, localPart, i * sizeof(XML_Char));
   2932   /* we always have a namespace separator between localPart and prefix */
   2933   if (prefixLen) {
   2934     uri += i - 1;
   2935     *uri = namespaceSeparator;  /* replace null terminator */
   2936     memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
   2937   }
   2938   tagNamePtr->str = binding->uri;
   2939   return XML_ERROR_NONE;
   2940 }
   2941 
   2942 /* addBinding() overwrites the value of prefix->binding without checking.
   2943    Therefore one must keep track of the old value outside of addBinding().
   2944 */
   2945 static enum XML_Error
   2946 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
   2947            const XML_Char *uri, BINDING **bindingsPtr)
   2948 {
   2949   static const XML_Char xmlNamespace[] = {
   2950     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
   2951     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
   2952     ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L,
   2953     ASCII_SLASH, ASCII_1, ASCII_9, ASCII_9, ASCII_8, ASCII_SLASH,
   2954     ASCII_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
   2955     ASCII_e, '\0'
   2956   };
   2957   static const int xmlLen =
   2958     (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
   2959   static const XML_Char xmlnsNamespace[] = {
   2960     ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,
   2961     ASCII_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
   2962     ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
   2963     ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
   2964     ASCII_SLASH, '\0'
   2965   };
   2966   static const int xmlnsLen =
   2967     (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
   2968 
   2969   XML_Bool mustBeXML = XML_FALSE;
   2970   XML_Bool isXML = XML_TRUE;
   2971   XML_Bool isXMLNS = XML_TRUE;
   2972 
   2973   BINDING *b;
   2974   int len;
   2975 
   2976   /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
   2977   if (*uri == XML_T('\0') && prefix->name)
   2978     return XML_ERROR_UNDECLARING_PREFIX;
   2979 
   2980   if (prefix->name
   2981       && prefix->name[0] == XML_T(ASCII_x)
   2982       && prefix->name[1] == XML_T(ASCII_m)
   2983       && prefix->name[2] == XML_T(ASCII_l)) {
   2984 
   2985     /* Not allowed to bind xmlns */
   2986     if (prefix->name[3] == XML_T(ASCII_n)
   2987         && prefix->name[4] == XML_T(ASCII_s)
   2988         && prefix->name[5] == XML_T('\0'))
   2989       return XML_ERROR_RESERVED_PREFIX_XMLNS;
   2990 
   2991     if (prefix->name[3] == XML_T('\0'))
   2992       mustBeXML = XML_TRUE;
   2993   }
   2994 
   2995   for (len = 0; uri[len]; len++) {
   2996     if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
   2997       isXML = XML_FALSE;
   2998 
   2999     if (!mustBeXML && isXMLNS
   3000         && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
   3001       isXMLNS = XML_FALSE;
   3002   }
   3003   isXML = isXML && len == xmlLen;
   3004   isXMLNS = isXMLNS && len == xmlnsLen;
   3005 
   3006   if (mustBeXML != isXML)
   3007     return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
   3008                      : XML_ERROR_RESERVED_NAMESPACE_URI;
   3009 
   3010   if (isXMLNS)
   3011     return XML_ERROR_RESERVED_NAMESPACE_URI;
   3012 
   3013   if (namespaceSeparator)
   3014     len++;
   3015   if (freeBindingList) {
   3016     b = freeBindingList;
   3017     if (len > b->uriAlloc) {
   3018       XML_Char *temp = (XML_Char *)REALLOC(b->uri,
   3019                           sizeof(XML_Char) * (len + EXPAND_SPARE));
   3020       if (temp == NULL)
   3021         return XML_ERROR_NO_MEMORY;
   3022       b->uri = temp;
   3023       b->uriAlloc = len + EXPAND_SPARE;
   3024     }
   3025     freeBindingList = b->nextTagBinding;
   3026   }
   3027   else {
   3028     b = (BINDING *)MALLOC(sizeof(BINDING));
   3029     if (!b)
   3030       return XML_ERROR_NO_MEMORY;
   3031     b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
   3032     if (!b->uri) {
   3033       FREE(b);
   3034       return XML_ERROR_NO_MEMORY;
   3035     }
   3036     b->uriAlloc = len + EXPAND_SPARE;
   3037   }
   3038   b->uriLen = len;
   3039   memcpy(b->uri, uri, len * sizeof(XML_Char));
   3040   if (namespaceSeparator)
   3041     b->uri[len - 1] = namespaceSeparator;
   3042   b->prefix = prefix;
   3043   b->attId = attId;
   3044   b->prevPrefixBinding = prefix->binding;
   3045   /* NULL binding when default namespace undeclared */
   3046   if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)
   3047     prefix->binding = NULL;
   3048   else
   3049     prefix->binding = b;
   3050   b->nextTagBinding = *bindingsPtr;
   3051   *bindingsPtr = b;
   3052   /* if attId == NULL then we are not starting a namespace scope */
   3053   if (attId && startNamespaceDeclHandler)
   3054     startNamespaceDeclHandler(handlerArg, prefix->name,
   3055                               prefix->binding ? uri : 0);
   3056   return XML_ERROR_NONE;
   3057 }
   3058 
   3059 /* The idea here is to avoid using stack for each CDATA section when
   3060    the whole file is parsed with one call.
   3061 */
   3062 static enum XML_Error PTRCALL
   3063 cdataSectionProcessor(XML_Parser parser,
   3064                       const char *start,
   3065                       const char *end,
   3066                       const char **endPtr)
   3067 {
   3068   enum XML_Error result = doCdataSection(parser, encoding, &start, end,
   3069                                          endPtr, (XML_Bool)!ps_finalBuffer);
   3070   if (result != XML_ERROR_NONE)
   3071     return result;
   3072   if (start) {
   3073     if (parentParser) {  /* we are parsing an external entity */
   3074       processor = externalEntityContentProcessor;
   3075       return externalEntityContentProcessor(parser, start, end, endPtr);
   3076     }
   3077     else {
   3078       processor = contentProcessor;
   3079       return contentProcessor(parser, start, end, endPtr);
   3080     }
   3081   }
   3082   return result;
   3083 }
   3084 
   3085 /* startPtr gets set to non-null if the section is closed, and to null if
   3086    the section is not yet closed.
   3087 */
   3088 static enum XML_Error
   3089 doCdataSection(XML_Parser parser,
   3090                const ENCODING *enc,
   3091                const char **startPtr,
   3092                const char *end,
   3093                const char **nextPtr,
   3094                XML_Bool haveMore)
   3095 {
   3096   const char *s = *startPtr;
   3097   const char **eventPP;
   3098   const char **eventEndPP;
   3099   if (enc == encoding) {
   3100     eventPP = &eventPtr;
   3101     *eventPP = s;
   3102     eventEndPP = &eventEndPtr;
   3103   }
   3104   else {
   3105     eventPP = &(openInternalEntities->internalEventPtr);
   3106     eventEndPP = &(openInternalEntities->internalEventEndPtr);
   3107   }
   3108   *eventPP = s;
   3109   *startPtr = NULL;
   3110 
   3111   for (;;) {
   3112     const char *next;
   3113     int tok = XmlCdataSectionTok(enc, s, end, &next);
   3114     *eventEndPP = next;
   3115     switch (tok) {
   3116     case XML_TOK_CDATA_SECT_CLOSE:
   3117       if (endCdataSectionHandler)
   3118         endCdataSectionHandler(handlerArg);
   3119 #if 0
   3120       /* see comment under XML_TOK_CDATA_SECT_OPEN */
   3121       else if (characterDataHandler)
   3122         characterDataHandler(handlerArg, dataBuf, 0);
   3123 #endif
   3124       else if (defaultHandler)
   3125         reportDefault(parser, enc, s, next);
   3126       *startPtr = next;
   3127       *nextPtr = next;
   3128       if (ps_parsing == XML_FINISHED)
   3129         return XML_ERROR_ABORTED;
   3130       else
   3131         return XML_ERROR_NONE;
   3132     case XML_TOK_DATA_NEWLINE:
   3133       if (characterDataHandler) {
   3134         XML_Char c = 0xA;
   3135         characterDataHandler(handlerArg, &c, 1);
   3136       }
   3137       else if (defaultHandler)
   3138         reportDefault(parser, enc, s, next);
   3139       break;
   3140     case XML_TOK_DATA_CHARS:
   3141       {
   3142         XML_CharacterDataHandler charDataHandler = characterDataHandler;
   3143         if (charDataHandler) {
   3144           if (MUST_CONVERT(enc, s)) {
   3145             for (;;) {
   3146               ICHAR *dataPtr = (ICHAR *)dataBuf;
   3147               XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
   3148               *eventEndPP = next;
   3149               charDataHandler(handlerArg, dataBuf,
   3150                               (int)(dataPtr - (ICHAR *)dataBuf));
   3151               if (s == next)
   3152                 break;
   3153               *eventPP = s;
   3154             }
   3155           }
   3156           else
   3157             charDataHandler(handlerArg,
   3158                             (XML_Char *)s,
   3159                             (int)((XML_Char *)next - (XML_Char *)s));
   3160         }
   3161         else if (defaultHandler)
   3162           reportDefault(parser, enc, s, next);
   3163       }
   3164       break;
   3165     case XML_TOK_INVALID:
   3166       *eventPP = next;
   3167       return XML_ERROR_INVALID_TOKEN;
   3168     case XML_TOK_PARTIAL_CHAR:
   3169       if (haveMore) {
   3170         *nextPtr = s;
   3171         return XML_ERROR_NONE;
   3172       }
   3173       return XML_ERROR_PARTIAL_CHAR;
   3174     case XML_TOK_PARTIAL:
   3175     case XML_TOK_NONE:
   3176       if (haveMore) {
   3177         *nextPtr = s;
   3178         return XML_ERROR_NONE;
   3179       }
   3180       return XML_ERROR_UNCLOSED_CDATA_SECTION;
   3181     default:
   3182       *eventPP = next;
   3183       return XML_ERROR_UNEXPECTED_STATE;
   3184     }
   3185 
   3186     *eventPP = s = next;
   3187     switch (ps_parsing) {
   3188     case XML_SUSPENDED:
   3189       *nextPtr = next;
   3190       return XML_ERROR_NONE;
   3191     case XML_FINISHED:
   3192       return XML_ERROR_ABORTED;
   3193     default: ;
   3194     }
   3195   }
   3196   /* not reached */
   3197 }
   3198 
   3199 #ifdef XML_DTD
   3200 
   3201 /* The idea here is to avoid using stack for each IGNORE section when
   3202    the whole file is parsed with one call.
   3203 */
   3204 static enum XML_Error PTRCALL
   3205 ignoreSectionProcessor(XML_Parser parser,
   3206                        const char *start,
   3207                        const char *end,
   3208                        const char **endPtr)
   3209 {
   3210   enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
   3211                                           endPtr, (XML_Bool)!ps_finalBuffer);
   3212   if (result != XML_ERROR_NONE)
   3213     return result;
   3214   if (start) {
   3215     processor = prologProcessor;
   3216     return prologProcessor(parser, start, end, endPtr);
   3217   }
   3218   return result;
   3219 }
   3220 
   3221 /* startPtr gets set to non-null is the section is closed, and to null
   3222    if the section is not yet closed.
   3223 */
   3224 static enum XML_Error
   3225 doIgnoreSection(XML_Parser parser,
   3226                 const ENCODING *enc,
   3227                 const char **startPtr,
   3228                 const char *end,
   3229                 const char **nextPtr,
   3230                 XML_Bool haveMore)
   3231 {
   3232   const char *next;
   3233   int tok;
   3234   const char *s = *startPtr;
   3235   const char **eventPP;
   3236   const char **eventEndPP;
   3237   if (enc == encoding) {
   3238     eventPP = &eventPtr;
   3239     *eventPP = s;
   3240     eventEndPP = &eventEndPtr;
   3241   }
   3242   else {
   3243     eventPP = &(openInternalEntities->internalEventPtr);
   3244     eventEndPP = &(openInternalEntities->internalEventEndPtr);
   3245   }
   3246   *eventPP = s;
   3247   *startPtr = NULL;
   3248   tok = XmlIgnoreSectionTok(enc, s, end, &next);
   3249   *eventEndPP = next;
   3250   switch (tok) {
   3251   case XML_TOK_IGNORE_SECT:
   3252     if (defaultHandler)
   3253       reportDefault(parser, enc, s, next);
   3254     *startPtr = next;
   3255     *nextPtr = next;
   3256     if (ps_parsing == XML_FINISHED)
   3257       return XML_ERROR_ABORTED;
   3258     else
   3259       return XML_ERROR_NONE;
   3260   case XML_TOK_INVALID:
   3261     *eventPP = next;
   3262     return XML_ERROR_INVALID_TOKEN;
   3263   case XML_TOK_PARTIAL_CHAR:
   3264     if (haveMore) {
   3265       *nextPtr = s;
   3266       return XML_ERROR_NONE;
   3267     }
   3268     return XML_ERROR_PARTIAL_CHAR;
   3269   case XML_TOK_PARTIAL:
   3270   case XML_TOK_NONE:
   3271     if (haveMore) {
   3272       *nextPtr = s;
   3273       return XML_ERROR_NONE;
   3274     }
   3275     return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
   3276   default:
   3277     *eventPP = next;
   3278     return XML_ERROR_UNEXPECTED_STATE;
   3279   }
   3280   /* not reached */
   3281 }
   3282 
   3283 #endif /* XML_DTD */
   3284 
   3285 static enum XML_Error
   3286 initializeEncoding(XML_Parser parser)
   3287 {
   3288   const char *s;
   3289 #ifdef XML_UNICODE
   3290   char encodingBuf[128];
   3291   if (!protocolEncodingName)
   3292     s = NULL;
   3293   else {
   3294     int i;
   3295     for (i = 0; protocolEncodingName[i]; i++) {
   3296       if (i == sizeof(encodingBuf) - 1
   3297           || (protocolEncodingName[i] & ~0x7f) != 0) {
   3298         encodingBuf[0] = '\0';
   3299         break;
   3300       }
   3301       encodingBuf[i] = (char)protocolEncodingName[i];
   3302     }
   3303     encodingBuf[i] = '\0';
   3304     s = encodingBuf;
   3305   }
   3306 #else
   3307   s = protocolEncodingName;
   3308 #endif
   3309   if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
   3310     return XML_ERROR_NONE;
   3311   return handleUnknownEncoding(parser, protocolEncodingName);
   3312 }
   3313 
   3314 static enum XML_Error
   3315 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
   3316                const char *s, const char *next)
   3317 {
   3318   const char *encodingName = NULL;
   3319   const XML_Char *storedEncName = NULL;
   3320   const ENCODING *newEncoding = NULL;
   3321   const char *version = NULL;
   3322   const char *versionend;
   3323   const XML_Char *storedversion = NULL;
   3324   int standalone = -1;
   3325   if (!(ns
   3326         ? XmlParseXmlDeclNS
   3327         : XmlParseXmlDecl)(isGeneralTextEntity,
   3328                            encoding,
   3329                            s,
   3330                            next,
   3331                            &eventPtr,
   3332                            &version,
   3333                            &versionend,
   3334                            &encodingName,
   3335                            &newEncoding,
   3336                            &standalone)) {
   3337     if (isGeneralTextEntity)
   3338       return XML_ERROR_TEXT_DECL;
   3339     else
   3340       return XML_ERROR_XML_DECL;
   3341   }
   3342   if (!isGeneralTextEntity && standalone == 1) {
   3343     _dtd->standalone = XML_TRUE;
   3344 #ifdef XML_DTD
   3345     if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
   3346       paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
   3347 #endif /* XML_DTD */
   3348   }
   3349   if (xmlDeclHandler) {
   3350     if (encodingName != NULL) {
   3351       storedEncName = poolStoreString(&temp2Pool,
   3352                                       encoding,
   3353                                       encodingName,
   3354                                       encodingName
   3355                                       + XmlNameLength(encoding, encodingName));
   3356       if (!storedEncName)
   3357               return XML_ERROR_NO_MEMORY;
   3358       poolFinish(&temp2Pool);
   3359     }
   3360     if (version) {
   3361       storedversion = poolStoreString(&temp2Pool,
   3362                                       encoding,
   3363                                       version,
   3364                                       versionend - encoding->minBytesPerChar);
   3365       if (!storedversion)
   3366         return XML_ERROR_NO_MEMORY;
   3367     }
   3368     xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);
   3369   }
   3370   else if (defaultHandler)
   3371     reportDefault(parser, encoding, s, next);
   3372   if (protocolEncodingName == NULL) {
   3373     if (newEncoding) {
   3374       if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
   3375         eventPtr = encodingName;
   3376         return XML_ERROR_INCORRECT_ENCODING;
   3377       }
   3378       encoding = newEncoding;
   3379     }
   3380     else if (encodingName) {
   3381       enum XML_Error result;
   3382       if (!storedEncName) {
   3383         storedEncName = poolStoreString(
   3384           &temp2Pool, encoding, encodingName,
   3385           encodingName + XmlNameLength(encoding, encodingName));
   3386         if (!storedEncName)
   3387           return XML_ERROR_NO_MEMORY;
   3388       }
   3389       result = handleUnknownEncoding(parser, storedEncName);
   3390       poolClear(&temp2Pool);
   3391       if (result == XML_ERROR_UNKNOWN_ENCODING)
   3392         eventPtr = encodingName;
   3393       return result;
   3394     }
   3395   }
   3396 
   3397   if (storedEncName || storedversion)
   3398     poolClear(&temp2Pool);
   3399 
   3400   return XML_ERROR_NONE;
   3401 }
   3402 
   3403 static enum XML_Error
   3404 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
   3405 {
   3406   if (unknownEncodingHandler) {
   3407     XML_Encoding info;
   3408     int i;
   3409     for (i = 0; i < 256; i++)
   3410       info.map[i] = -1;
   3411     info.convert = NULL;
   3412     info.data = NULL;
   3413     info.release = NULL;
   3414     if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,
   3415                                &info)) {
   3416       ENCODING *enc;
   3417       unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
   3418       if (!unknownEncodingMem) {
   3419         if (info.release)
   3420           info.release(info.data);
   3421         return XML_ERROR_NO_MEMORY;
   3422       }
   3423       enc = (ns
   3424              ? XmlInitUnknownEncodingNS
   3425              : XmlInitUnknownEncoding)(unknownEncodingMem,
   3426                                        info.map,
   3427                                        info.convert,
   3428                                        info.data);
   3429       if (enc) {
   3430         unknownEncodingData = info.data;
   3431         unknownEncodingRelease = info.release;
   3432         encoding = enc;
   3433         return XML_ERROR_NONE;
   3434       }
   3435     }
   3436     if (info.release != NULL)
   3437       info.release(info.data);
   3438   }
   3439   return XML_ERROR_UNKNOWN_ENCODING;
   3440 }
   3441 
   3442 static enum XML_Error PTRCALL
   3443 prologInitProcessor(XML_Parser parser,
   3444                     const char *s,
   3445                     const char *end,
   3446                     const char **nextPtr)
   3447 {
   3448   enum XML_Error result = initializeEncoding(parser);
   3449   if (result != XML_ERROR_NONE)
   3450     return result;
   3451   processor = prologProcessor;
   3452   return prologProcessor(parser, s, end, nextPtr);
   3453 }
   3454 
   3455 #ifdef XML_DTD
   3456 
   3457 static enum XML_Error PTRCALL
   3458 externalParEntInitProcessor(XML_Parser parser,
   3459                             const char *s,
   3460                             const char *end,
   3461                             const char **nextPtr)
   3462 {
   3463   enum XML_Error result = initializeEncoding(parser);
   3464   if (result != XML_ERROR_NONE)
   3465     return result;
   3466 
   3467   /* we know now that XML_Parse(Buffer) has been called,
   3468      so we consider the external parameter entity read */
   3469   _dtd->paramEntityRead = XML_TRUE;
   3470 
   3471   if (prologState.inEntityValue) {
   3472     processor = entityValueInitProcessor;
   3473     return entityValueInitProcessor(parser, s, end, nextPtr);
   3474   }
   3475   else {
   3476     processor = externalParEntProcessor;
   3477     return externalParEntProcessor(parser, s, end, nextPtr);
   3478   }
   3479 }
   3480 
   3481 static enum XML_Error PTRCALL
   3482 entityValueInitProcessor(XML_Parser parser,
   3483                          const char *s,
   3484                          const char *end,
   3485                          const char **nextPtr)
   3486 {
   3487   int tok;
   3488   const char *start = s;
   3489   const char *next = start;
   3490   eventPtr = start;
   3491 
   3492   for (;;) {
   3493     tok = XmlPrologTok(encoding, start, end, &next);
   3494     eventEndPtr = next;
   3495     if (tok <= 0) {
   3496       if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
   3497         *nextPtr = s;
   3498         return XML_ERROR_NONE;
   3499       }
   3500       switch (tok) {
   3501       case XML_TOK_INVALID:
   3502         return XML_ERROR_INVALID_TOKEN;
   3503       case XML_TOK_PARTIAL:
   3504         return XML_ERROR_UNCLOSED_TOKEN;
   3505       case XML_TOK_PARTIAL_CHAR:
   3506         return XML_ERROR_PARTIAL_CHAR;
   3507       case XML_TOK_NONE:   /* start == end */
   3508       default:
   3509         break;
   3510       }
   3511       /* found end of entity value - can store it now */
   3512       return storeEntityValue(parser, encoding, s, end);
   3513     }
   3514     else if (tok == XML_TOK_XML_DECL) {
   3515       enum XML_Error result;
   3516       result = processXmlDecl(parser, 0, start, next);
   3517       if (result != XML_ERROR_NONE)
   3518         return result;
   3519       switch (ps_parsing) {
   3520       case XML_SUSPENDED:
   3521         *nextPtr = next;
   3522         return XML_ERROR_NONE;
   3523       case XML_FINISHED:
   3524         return XML_ERROR_ABORTED;
   3525       default:
   3526         *nextPtr = next;
   3527       }
   3528       /* stop scanning for text declaration - we found one */
   3529       processor = entityValueProcessor;
   3530       return entityValueProcessor(parser, next, end, nextPtr);
   3531     }
   3532     /* If we are at the end of the buffer, this would cause XmlPrologTok to
   3533        return XML_TOK_NONE on the next call, which would then cause the
   3534        function to exit with *nextPtr set to s - that is what we want for other
   3535        tokens, but not for the BOM - we would rather like to skip it;
   3536        then, when this routine is entered the next time, XmlPrologTok will
   3537        return XML_TOK_INVALID, since the BOM is still in the buffer
   3538     */
   3539     else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {
   3540       *nextPtr = next;
   3541       return XML_ERROR_NONE;
   3542     }
   3543     start = next;
   3544     eventPtr = start;
   3545   }
   3546 }
   3547 
   3548 static enum XML_Error PTRCALL
   3549 externalParEntProcessor(XML_Parser parser,
   3550                         const char *s,
   3551                         const char *end,
   3552                         const char **nextPtr)
   3553 {
   3554   const char *next = s;
   3555   int tok;
   3556 
   3557   tok = XmlPrologTok(encoding, s, end, &next);
   3558   if (tok <= 0) {
   3559     if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
   3560       *nextPtr = s;
   3561       return XML_ERROR_NONE;
   3562     }
   3563     switch (tok) {
   3564     case XML_TOK_INVALID:
   3565       return XML_ERROR_INVALID_TOKEN;
   3566     case XML_TOK_PARTIAL:
   3567       return XML_ERROR_UNCLOSED_TOKEN;
   3568     case XML_TOK_PARTIAL_CHAR:
   3569       return XML_ERROR_PARTIAL_CHAR;
   3570     case XML_TOK_NONE:   /* start == end */
   3571     default:
   3572       break;
   3573     }
   3574   }
   3575   /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
   3576      However, when parsing an external subset, doProlog will not accept a BOM
   3577      as valid, and report a syntax error, so we have to skip the BOM
   3578   */
   3579   else if (tok == XML_TOK_BOM) {
   3580     s = next;
   3581     tok = XmlPrologTok(encoding, s, end, &next);
   3582   }
   3583 
   3584   processor = prologProcessor;
   3585   return doProlog(parser, encoding, s, end, tok, next,
   3586                   nextPtr, (XML_Bool)!ps_finalBuffer);
   3587 }
   3588 
   3589 static enum XML_Error PTRCALL
   3590 entityValueProcessor(XML_Parser parser,
   3591                      const char *s,
   3592                      const char *end,
   3593                      const char **nextPtr)
   3594 {
   3595   const char *start = s;
   3596   const char *next = s;
   3597   const ENCODING *enc = encoding;
   3598   int tok;
   3599 
   3600   for (;;) {
   3601     tok = XmlPrologTok(enc, start, end, &next);
   3602     if (tok <= 0) {
   3603       if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
   3604         *nextPtr = s;
   3605         return XML_ERROR_NONE;
   3606       }
   3607       switch (tok) {
   3608       case XML_TOK_INVALID:
   3609         return XML_ERROR_INVALID_TOKEN;
   3610       case XML_TOK_PARTIAL:
   3611         return XML_ERROR_UNCLOSED_TOKEN;
   3612       case XML_TOK_PARTIAL_CHAR:
   3613         return XML_ERROR_PARTIAL_CHAR;
   3614       case XML_TOK_NONE:   /* start == end */
   3615       default:
   3616         break;
   3617       }
   3618       /* found end of entity value - can store it now */
   3619       return storeEntityValue(parser, enc, s, end);
   3620     }
   3621     start = next;
   3622   }
   3623 }
   3624 
   3625 #endif /* XML_DTD */
   3626 
   3627 static enum XML_Error PTRCALL
   3628 prologProcessor(XML_Parser parser,
   3629                 const char *s,
   3630                 const char *end,
   3631                 const char **nextPtr)
   3632 {
   3633   const char *next = s;
   3634   int tok = XmlPrologTok(encoding, s, end, &next);
   3635   return doProlog(parser, encoding, s, end, tok, next,
   3636                   nextPtr, (XML_Bool)!ps_finalBuffer);
   3637 }
   3638 
   3639 static enum XML_Error
   3640 doProlog(XML_Parser parser,
   3641          const ENCODING *enc,
   3642          const char *s,
   3643          const char *end,
   3644          int tok,
   3645          const char *next,
   3646          const char **nextPtr,
   3647          XML_Bool haveMore)
   3648 {
   3649 #ifdef XML_DTD
   3650   static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
   3651 #endif /* XML_DTD */
   3652   static const XML_Char atypeCDATA[] =
   3653       { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
   3654   static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
   3655   static const XML_Char atypeIDREF[] =
   3656       { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
   3657   static const XML_Char atypeIDREFS[] =
   3658       { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
   3659   static const XML_Char atypeENTITY[] =
   3660       { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
   3661   static const XML_Char atypeENTITIES[] = { ASCII_E, ASCII_N,
   3662       ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
   3663   static const XML_Char atypeNMTOKEN[] = {
   3664       ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
   3665   static const XML_Char atypeNMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T,
   3666       ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
   3667   static const XML_Char notationPrefix[] = { ASCII_N, ASCII_O, ASCII_T,
   3668       ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0' };
   3669   static const XML_Char enumValueSep[] = { ASCII_PIPE, '\0' };
   3670   static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
   3671 
   3672   /* save one level of indirection */
   3673   DTD * const dtd = _dtd;
   3674 
   3675   const char **eventPP;
   3676   const char **eventEndPP;
   3677   enum XML_Content_Quant quant;
   3678 
   3679   if (enc == encoding) {
   3680     eventPP = &eventPtr;
   3681     eventEndPP = &eventEndPtr;
   3682   }
   3683   else {
   3684     eventPP = &(openInternalEntities->internalEventPtr);
   3685     eventEndPP = &(openInternalEntities->internalEventEndPtr);
   3686   }
   3687 
   3688   for (;;) {
   3689     int role;
   3690     XML_Bool handleDefault = XML_TRUE;
   3691     *eventPP = s;
   3692     *eventEndPP = next;
   3693     if (tok <= 0) {
   3694       if (haveMore && tok != XML_TOK_INVALID) {
   3695         *nextPtr = s;
   3696         return XML_ERROR_NONE;
   3697       }
   3698       switch (tok) {
   3699       case XML_TOK_INVALID:
   3700         *eventPP = next;
   3701         return XML_ERROR_INVALID_TOKEN;
   3702       case XML_TOK_PARTIAL:
   3703         return XML_ERROR_UNCLOSED_TOKEN;
   3704       case XML_TOK_PARTIAL_CHAR:
   3705         return XML_ERROR_PARTIAL_CHAR;
   3706       case XML_TOK_NONE:
   3707 #ifdef XML_DTD
   3708         /* for internal PE NOT referenced between declarations */
   3709         if (enc != encoding && !openInternalEntities->betweenDecl) {
   3710           *nextPtr = s;
   3711           return XML_ERROR_NONE;
   3712         }
   3713         /* WFC: PE Between Declarations - must check that PE contains
   3714            complete markup, not only for external PEs, but also for
   3715            internal PEs if the reference occurs between declarations.
   3716         */
   3717         if (isParamEntity || enc != encoding) {
   3718           if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)
   3719               == XML_ROLE_ERROR)
   3720             return XML_ERROR_INCOMPLETE_PE;
   3721           *nextPtr = s;
   3722           return XML_ERROR_NONE;
   3723         }
   3724 #endif /* XML_DTD */
   3725         return XML_ERROR_NO_ELEMENTS;
   3726       default:
   3727         tok = -tok;
   3728         next = end;
   3729         break;
   3730       }
   3731     }
   3732     role = XmlTokenRole(&prologState, tok, s, next, enc);
   3733     switch (role) {
   3734     case XML_ROLE_XML_DECL:
   3735       {
   3736         enum XML_Error result = processXmlDecl(parser, 0, s, next);
   3737         if (result != XML_ERROR_NONE)
   3738           return result;
   3739         enc = encoding;
   3740         handleDefault = XML_FALSE;
   3741       }
   3742       break;
   3743     case XML_ROLE_DOCTYPE_NAME:
   3744       if (startDoctypeDeclHandler) {
   3745         doctypeName = poolStoreString(&tempPool, enc, s, next);
   3746         if (!doctypeName)
   3747           return XML_ERROR_NO_MEMORY;
   3748         poolFinish(&tempPool);
   3749         doctypePubid = NULL;
   3750         handleDefault = XML_FALSE;
   3751       }
   3752       doctypeSysid = NULL; /* always initialize to NULL */
   3753       break;
   3754     case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
   3755       if (startDoctypeDeclHandler) {
   3756         startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,
   3757                                 doctypePubid, 1);
   3758         doctypeName = NULL;
   3759         poolClear(&tempPool);
   3760         handleDefault = XML_FALSE;
   3761       }
   3762       break;
   3763 #ifdef XML_DTD
   3764     case XML_ROLE_TEXT_DECL:
   3765       {
   3766         enum XML_Error result = processXmlDecl(parser, 1, s, next);
   3767         if (result != XML_ERROR_NONE)
   3768           return result;
   3769         enc = encoding;
   3770         handleDefault = XML_FALSE;
   3771       }
   3772       break;
   3773 #endif /* XML_DTD */
   3774     case XML_ROLE_DOCTYPE_PUBLIC_ID:
   3775 #ifdef XML_DTD
   3776       useForeignDTD = XML_FALSE;
   3777       declEntity = (ENTITY *)lookup(&dtd->paramEntities,
   3778                                     externalSubsetName,
   3779                                     sizeof(ENTITY));
   3780       if (!declEntity)
   3781         return XML_ERROR_NO_MEMORY;
   3782 #endif /* XML_DTD */
   3783       dtd->hasParamEntityRefs = XML_TRUE;
   3784       if (startDoctypeDeclHandler) {
   3785         if (!XmlIsPublicId(enc, s, next, eventPP))
   3786           return XML_ERROR_PUBLICID;
   3787         doctypePubid = poolStoreString(&tempPool, enc,
   3788                                        s + enc->minBytesPerChar,
   3789                                        next - enc->minBytesPerChar);
   3790         if (!doctypePubid)
   3791           return XML_ERROR_NO_MEMORY;
   3792         normalizePublicId((XML_Char *)doctypePubid);
   3793         poolFinish(&tempPool);
   3794         handleDefault = XML_FALSE;
   3795         goto alreadyChecked;
   3796       }
   3797       /* fall through */
   3798     case XML_ROLE_ENTITY_PUBLIC_ID:
   3799       if (!XmlIsPublicId(enc, s, next, eventPP))
   3800         return XML_ERROR_PUBLICID;
   3801     alreadyChecked:
   3802       if (dtd->keepProcessing && declEntity) {
   3803         XML_Char *tem = poolStoreString(&dtd->pool,
   3804                                         enc,
   3805                                         s + enc->minBytesPerChar,
   3806                                         next - enc->minBytesPerChar);
   3807         if (!tem)
   3808           return XML_ERROR_NO_MEMORY;
   3809         normalizePublicId(tem);
   3810         declEntity->publicId = tem;
   3811         poolFinish(&dtd->pool);
   3812         if (entityDeclHandler)
   3813           handleDefault = XML_FALSE;
   3814       }
   3815       break;
   3816     case XML_ROLE_DOCTYPE_CLOSE:
   3817       if (doctypeName) {
   3818         startDoctypeDeclHandler(handlerArg, doctypeName,
   3819                                 doctypeSysid, doctypePubid, 0);
   3820         poolClear(&tempPool);
   3821         handleDefault = XML_FALSE;
   3822       }
   3823       /* doctypeSysid will be non-NULL in the case of a previous
   3824          XML_ROLE_DOCTYPE_SYSTEM_ID, even if startDoctypeDeclHandler
   3825          was not set, indicating an external subset
   3826       */
   3827 #ifdef XML_DTD
   3828       if (doctypeSysid || useForeignDTD) {
   3829         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
   3830         dtd->hasParamEntityRefs = XML_TRUE;
   3831         if (paramEntityParsing && externalEntityRefHandler) {
   3832           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
   3833                                             externalSubsetName,
   3834                                             sizeof(ENTITY));
   3835           if (!entity)
   3836             return XML_ERROR_NO_MEMORY;
   3837           if (useForeignDTD)
   3838             entity->base = curBase;
   3839           dtd->paramEntityRead = XML_FALSE;
   3840           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
   3841                                         0,
   3842                                         entity->base,
   3843                                         entity->systemId,
   3844                                         entity->publicId))
   3845             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
   3846           if (dtd->paramEntityRead) {
   3847             if (!dtd->standalone &&
   3848                 notStandaloneHandler &&
   3849                 !notStandaloneHandler(handlerArg))
   3850               return XML_ERROR_NOT_STANDALONE;
   3851           }
   3852           /* if we didn't read the foreign DTD then this means that there
   3853              is no external subset and we must reset dtd->hasParamEntityRefs
   3854           */
   3855           else if (!doctypeSysid)
   3856             dtd->hasParamEntityRefs = hadParamEntityRefs;
   3857           /* end of DTD - no need to update dtd->keepProcessing */
   3858         }
   3859         useForeignDTD = XML_FALSE;
   3860       }
   3861 #endif /* XML_DTD */
   3862       if (endDoctypeDeclHandler) {
   3863         endDoctypeDeclHandler(handlerArg);
   3864         handleDefault = XML_FALSE;
   3865       }
   3866       break;
   3867     case XML_ROLE_INSTANCE_START:
   3868 #ifdef XML_DTD
   3869       /* if there is no DOCTYPE declaration then now is the
   3870          last chance to read the foreign DTD
   3871       */
   3872       if (useForeignDTD) {
   3873         XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
   3874         dtd->hasParamEntityRefs = XML_TRUE;
   3875         if (paramEntityParsing && externalEntityRefHandler) {
   3876           ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
   3877                                             externalSubsetName,
   3878                                             sizeof(ENTITY));
   3879           if (!entity)
   3880             return XML_ERROR_NO_MEMORY;
   3881           entity->base = curBase;
   3882           dtd->paramEntityRead = XML_FALSE;
   3883           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
   3884                                         0,
   3885                                         entity->base,
   3886                                         entity->systemId,
   3887                                         entity->publicId))
   3888             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
   3889           if (dtd->paramEntityRead) {
   3890             if (!dtd->standalone &&
   3891                 notStandaloneHandler &&
   3892                 !notStandaloneHandler(handlerArg))
   3893               return XML_ERROR_NOT_STANDALONE;
   3894           }
   3895           /* if we didn't read the foreign DTD then this means that there
   3896              is no external subset and we must reset dtd->hasParamEntityRefs
   3897           */
   3898           else
   3899             dtd->hasParamEntityRefs = hadParamEntityRefs;
   3900           /* end of DTD - no need to update dtd->keepProcessing */
   3901         }
   3902       }
   3903 #endif /* XML_DTD */
   3904       processor = contentProcessor;
   3905       return contentProcessor(parser, s, end, nextPtr);
   3906     case XML_ROLE_ATTLIST_ELEMENT_NAME:
   3907       declElementType = getElementType(parser, enc, s, next);
   3908       if (!declElementType)
   3909         return XML_ERROR_NO_MEMORY;
   3910       goto checkAttListDeclHandler;
   3911     case XML_ROLE_ATTRIBUTE_NAME:
   3912       declAttributeId = getAttributeId(parser, enc, s, next);
   3913       if (!declAttributeId)
   3914         return XML_ERROR_NO_MEMORY;
   3915       declAttributeIsCdata = XML_FALSE;
   3916       declAttributeType = NULL;
   3917       declAttributeIsId = XML_FALSE;
   3918       goto checkAttListDeclHandler;
   3919     case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
   3920       declAttributeIsCdata = XML_TRUE;
   3921       declAttributeType = atypeCDATA;
   3922       goto checkAttListDeclHandler;
   3923     case XML_ROLE_ATTRIBUTE_TYPE_ID:
   3924       declAttributeIsId = XML_TRUE;
   3925       declAttributeType = atypeID;
   3926       goto checkAttListDeclHandler;
   3927     case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
   3928       declAttributeType = atypeIDREF;
   3929       goto checkAttListDeclHandler;
   3930     case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
   3931       declAttributeType = atypeIDREFS;
   3932       goto checkAttListDeclHandler;
   3933     case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
   3934       declAttributeType = atypeENTITY;
   3935       goto checkAttListDeclHandler;
   3936     case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
   3937       declAttributeType = atypeENTITIES;
   3938       goto checkAttListDeclHandler;
   3939     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
   3940       declAttributeType = atypeNMTOKEN;
   3941       goto checkAttListDeclHandler;
   3942     case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
   3943       declAttributeType = atypeNMTOKENS;
   3944     checkAttListDeclHandler:
   3945       if (dtd->keepProcessing && attlistDeclHandler)
   3946         handleDefault = XML_FALSE;
   3947       break;
   3948     case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
   3949     case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
   3950       if (dtd->keepProcessing && attlistDeclHandler) {
   3951         const XML_Char *prefix;
   3952         if (declAttributeType) {
   3953           prefix = enumValueSep;
   3954         }
   3955         else {
   3956           prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE
   3957                     ? notationPrefix
   3958                     : enumValueStart);
   3959         }
   3960         if (!poolAppendString(&tempPool, prefix))
   3961           return XML_ERROR_NO_MEMORY;
   3962         if (!poolAppend(&tempPool, enc, s, next))
   3963           return XML_ERROR_NO_MEMORY;
   3964         declAttributeType = tempPool.start;
   3965         handleDefault = XML_FALSE;
   3966       }
   3967       break;
   3968     case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
   3969     case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
   3970       if (dtd->keepProcessing) {
   3971         if (!defineAttribute(declElementType, declAttributeId,
   3972                              declAttributeIsCdata, declAttributeIsId,
   3973                              0, parser))
   3974           return XML_ERROR_NO_MEMORY;
   3975         if (attlistDeclHandler && declAttributeType) {
   3976           if (*declAttributeType == XML_T(ASCII_LPAREN)
   3977               || (*declAttributeType == XML_T(ASCII_N)
   3978                   && declAttributeType[1] == XML_T(ASCII_O))) {
   3979             /* Enumerated or Notation type */
   3980             if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
   3981                 || !poolAppendChar(&tempPool, XML_T('\0')))
   3982               return XML_ERROR_NO_MEMORY;
   3983             declAttributeType = tempPool.start;
   3984             poolFinish(&tempPool);
   3985           }
   3986           *eventEndPP = s;
   3987           attlistDeclHandler(handlerArg, declElementType->name,
   3988                              declAttributeId->name, declAttributeType,
   3989                              0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
   3990           poolClear(&tempPool);
   3991           handleDefault = XML_FALSE;
   3992         }
   3993       }
   3994       break;
   3995     case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
   3996     case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
   3997       if (dtd->keepProcessing) {
   3998         const XML_Char *attVal;
   3999         enum XML_Error result =
   4000           storeAttributeValue(parser, enc, declAttributeIsCdata,
   4001                               s + enc->minBytesPerChar,
   4002                               next - enc->minBytesPerChar,
   4003                               &dtd->pool);
   4004         if (result)
   4005           return result;
   4006         attVal = poolStart(&dtd->pool);
   4007         poolFinish(&dtd->pool);
   4008         /* ID attributes aren't allowed to have a default */
   4009         if (!defineAttribute(declElementType, declAttributeId,
   4010                              declAttributeIsCdata, XML_FALSE, attVal, parser))
   4011           return XML_ERROR_NO_MEMORY;
   4012         if (attlistDeclHandler && declAttributeType) {
   4013           if (*declAttributeType == XML_T(ASCII_LPAREN)
   4014               || (*declAttributeType == XML_T(ASCII_N)
   4015                   && declAttributeType[1] == XML_T(ASCII_O))) {
   4016             /* Enumerated or Notation type */
   4017             if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
   4018                 || !poolAppendChar(&tempPool, XML_T('\0')))
   4019               return XML_ERROR_NO_MEMORY;
   4020             declAttributeType = tempPool.start;
   4021             poolFinish(&tempPool);
   4022           }
   4023           *eventEndPP = s;
   4024           attlistDeclHandler(handlerArg, declElementType->name,
   4025                              declAttributeId->name, declAttributeType,
   4026                              attVal,
   4027                              role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
   4028           poolClear(&tempPool);
   4029           handleDefault = XML_FALSE;
   4030         }
   4031       }
   4032       break;
   4033     case XML_ROLE_ENTITY_VALUE:
   4034       if (dtd->keepProcessing) {
   4035         enum XML_Error result = storeEntityValue(parser, enc,
   4036                                             s + enc->minBytesPerChar,
   4037                                             next - enc->minBytesPerChar);
   4038         if (declEntity) {
   4039           declEntity->textPtr = poolStart(&dtd->entityValuePool);
   4040           declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));
   4041           poolFinish(&dtd->entityValuePool);
   4042           if (entityDeclHandler) {
   4043             *eventEndPP = s;
   4044             entityDeclHandler(handlerArg,
   4045                               declEntity->name,
   4046                               declEntity->is_param,
   4047                               declEntity->textPtr,
   4048                               declEntity->textLen,
   4049                               curBase, 0, 0, 0);
   4050             handleDefault = XML_FALSE;
   4051           }
   4052         }
   4053         else
   4054           poolDiscard(&dtd->entityValuePool);
   4055         if (result != XML_ERROR_NONE)
   4056           return result;
   4057       }
   4058       break;
   4059     case XML_ROLE_DOCTYPE_SYSTEM_ID:
   4060 #ifdef XML_DTD
   4061       useForeignDTD = XML_FALSE;
   4062 #endif /* XML_DTD */
   4063       dtd->hasParamEntityRefs = XML_TRUE;
   4064       if (startDoctypeDeclHandler) {
   4065         doctypeSysid = poolStoreString(&tempPool, enc,
   4066                                        s + enc->minBytesPerChar,
   4067                                        next - enc->minBytesPerChar);
   4068         if (doctypeSysid == NULL)
   4069           return XML_ERROR_NO_MEMORY;
   4070         poolFinish(&tempPool);
   4071         handleDefault = XML_FALSE;
   4072       }
   4073 #ifdef XML_DTD
   4074       else
   4075         /* use externalSubsetName to make doctypeSysid non-NULL
   4076            for the case where no startDoctypeDeclHandler is set */
   4077         doctypeSysid = externalSubsetName;
   4078 #endif /* XML_DTD */
   4079       if (!dtd->standalone
   4080 #ifdef XML_DTD
   4081           && !paramEntityParsing
   4082 #endif /* XML_DTD */
   4083           && notStandaloneHandler
   4084           && !notStandaloneHandler(handlerArg))
   4085         return XML_ERROR_NOT_STANDALONE;
   4086 #ifndef XML_DTD
   4087       break;
   4088 #else /* XML_DTD */
   4089       if (!declEntity) {
   4090         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
   4091                                       externalSubsetName,
   4092                                       sizeof(ENTITY));
   4093         if (!declEntity)
   4094           return XML_ERROR_NO_MEMORY;
   4095         declEntity->publicId = NULL;
   4096       }
   4097       /* fall through */
   4098 #endif /* XML_DTD */
   4099     case XML_ROLE_ENTITY_SYSTEM_ID:
   4100       if (dtd->keepProcessing && declEntity) {
   4101         declEntity->systemId = poolStoreString(&dtd->pool, enc,
   4102                                                s + enc->minBytesPerChar,
   4103                                                next - enc->minBytesPerChar);
   4104         if (!declEntity->systemId)
   4105           return XML_ERROR_NO_MEMORY;
   4106         declEntity->base = curBase;
   4107         poolFinish(&dtd->pool);
   4108         if (entityDeclHandler)
   4109           handleDefault = XML_FALSE;
   4110       }
   4111       break;
   4112     case XML_ROLE_ENTITY_COMPLETE:
   4113       if (dtd->keepProcessing && declEntity && entityDeclHandler) {
   4114         *eventEndPP = s;
   4115         entityDeclHandler(handlerArg,
   4116                           declEntity->name,
   4117                           declEntity->is_param,
   4118                           0,0,
   4119                           declEntity->base,
   4120                           declEntity->systemId,
   4121                           declEntity->publicId,
   4122                           0);
   4123         handleDefault = XML_FALSE;
   4124       }
   4125       break;
   4126     case XML_ROLE_ENTITY_NOTATION_NAME:
   4127       if (dtd->keepProcessing && declEntity) {
   4128         declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);
   4129         if (!declEntity->notation)
   4130           return XML_ERROR_NO_MEMORY;
   4131         poolFinish(&dtd->pool);
   4132         if (unparsedEntityDeclHandler) {
   4133           *eventEndPP = s;
   4134           unparsedEntityDeclHandler(handlerArg,
   4135                                     declEntity->name,
   4136                                     declEntity->base,
   4137                                     declEntity->systemId,
   4138                                     declEntity->publicId,
   4139                                     declEntity->notation);
   4140           handleDefault = XML_FALSE;
   4141         }
   4142         else if (entityDeclHandler) {
   4143           *eventEndPP = s;
   4144           entityDeclHandler(handlerArg,
   4145                             declEntity->name,
   4146                             0,0,0,
   4147                             declEntity->base,
   4148                             declEntity->systemId,
   4149                             declEntity->publicId,
   4150                             declEntity->notation);
   4151           handleDefault = XML_FALSE;
   4152         }
   4153       }
   4154       break;
   4155     case XML_ROLE_GENERAL_ENTITY_NAME:
   4156       {
   4157         if (XmlPredefinedEntityName(enc, s, next)) {
   4158           declEntity = NULL;
   4159           break;
   4160         }
   4161         if (dtd->keepProcessing) {
   4162           const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
   4163           if (!name)
   4164             return XML_ERROR_NO_MEMORY;
   4165           declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,
   4166                                         sizeof(ENTITY));
   4167           if (!declEntity)
   4168             return XML_ERROR_NO_MEMORY;
   4169           if (declEntity->name != name) {
   4170             poolDiscard(&dtd->pool);
   4171             declEntity = NULL;
   4172           }
   4173           else {
   4174             poolFinish(&dtd->pool);
   4175             declEntity->publicId = NULL;
   4176             declEntity->is_param = XML_FALSE;
   4177             /* if we have a parent parser or are reading an internal parameter
   4178                entity, then the entity declaration is not considered "internal"
   4179             */
   4180             declEntity->is_internal = !(parentParser || openInternalEntities);
   4181             if (entityDeclHandler)
   4182               handleDefault = XML_FALSE;
   4183           }
   4184         }
   4185         else {
   4186           poolDiscard(&dtd->pool);
   4187           declEntity = NULL;
   4188         }
   4189       }
   4190       break;
   4191     case XML_ROLE_PARAM_ENTITY_NAME:
   4192 #ifdef XML_DTD
   4193       if (dtd->keepProcessing) {
   4194         const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
   4195         if (!name)
   4196           return XML_ERROR_NO_MEMORY;
   4197         declEntity = (ENTITY *)lookup(&dtd->paramEntities,
   4198                                            name, sizeof(ENTITY));
   4199         if (!declEntity)
   4200           return XML_ERROR_NO_MEMORY;
   4201         if (declEntity->name != name) {
   4202           poolDiscard(&dtd->pool);
   4203           declEntity = NULL;
   4204         }
   4205         else {
   4206           poolFinish(&dtd->pool);
   4207           declEntity->publicId = NULL;
   4208           declEntity->is_param = XML_TRUE;
   4209           /* if we have a parent parser or are reading an internal parameter
   4210              entity, then the entity declaration is not considered "internal"
   4211           */
   4212           declEntity->is_internal = !(parentParser || openInternalEntities);
   4213           if (entityDeclHandler)
   4214             handleDefault = XML_FALSE;
   4215         }
   4216       }
   4217       else {
   4218         poolDiscard(&dtd->pool);
   4219         declEntity = NULL;
   4220       }
   4221 #else /* not XML_DTD */
   4222       declEntity = NULL;
   4223 #endif /* XML_DTD */
   4224       break;
   4225     case XML_ROLE_NOTATION_NAME:
   4226       declNotationPublicId = NULL;
   4227       declNotationName = NULL;
   4228       if (notationDeclHandler) {
   4229         declNotationName = poolStoreString(&tempPool, enc, s, next);
   4230         if (!declNotationName)
   4231           return XML_ERROR_NO_MEMORY;
   4232         poolFinish(&tempPool);
   4233         handleDefault = XML_FALSE;
   4234       }
   4235       break;
   4236     case XML_ROLE_NOTATION_PUBLIC_ID:
   4237       if (!XmlIsPublicId(enc, s, next, eventPP))
   4238         return XML_ERROR_PUBLICID;
   4239       if (declNotationName) {  /* means notationDeclHandler != NULL */
   4240         XML_Char *tem = poolStoreString(&tempPool,
   4241                                         enc,
   4242                                         s + enc->minBytesPerChar,
   4243                                         next - enc->minBytesPerChar);
   4244         if (!tem)
   4245           return XML_ERROR_NO_MEMORY;
   4246         normalizePublicId(tem);
   4247         declNotationPublicId = tem;
   4248         poolFinish(&tempPool);
   4249         handleDefault = XML_FALSE;
   4250       }
   4251       break;
   4252     case XML_ROLE_NOTATION_SYSTEM_ID:
   4253       if (declNotationName && notationDeclHandler) {
   4254         const XML_Char *systemId
   4255           = poolStoreString(&tempPool, enc,
   4256                             s + enc->minBytesPerChar,
   4257                             next - enc->minBytesPerChar);
   4258         if (!systemId)
   4259           return XML_ERROR_NO_MEMORY;
   4260         *eventEndPP = s;
   4261         notationDeclHandler(handlerArg,
   4262                             declNotationName,
   4263                             curBase,
   4264                             systemId,
   4265                             declNotationPublicId);
   4266         handleDefault = XML_FALSE;
   4267       }
   4268       poolClear(&tempPool);
   4269       break;
   4270     case XML_ROLE_NOTATION_NO_SYSTEM_ID:
   4271       if (declNotationPublicId && notationDeclHandler) {
   4272         *eventEndPP = s;
   4273         notationDeclHandler(handlerArg,
   4274                             declNotationName,
   4275                             curBase,
   4276                             0,
   4277                             declNotationPublicId);
   4278         handleDefault = XML_FALSE;
   4279       }
   4280       poolClear(&tempPool);
   4281       break;
   4282     case XML_ROLE_ERROR:
   4283       switch (tok) {
   4284       case XML_TOK_PARAM_ENTITY_REF:
   4285         /* PE references in internal subset are
   4286            not allowed within declarations. */
   4287         return XML_ERROR_PARAM_ENTITY_REF;
   4288       case XML_TOK_XML_DECL:
   4289         return XML_ERROR_MISPLACED_XML_PI;
   4290       default:
   4291         return XML_ERROR_SYNTAX;
   4292       }
   4293 #ifdef XML_DTD
   4294     case XML_ROLE_IGNORE_SECT:
   4295       {
   4296         enum XML_Error result;
   4297         if (defaultHandler)
   4298           reportDefault(parser, enc, s, next);
   4299         handleDefault = XML_FALSE;
   4300         result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
   4301         if (result != XML_ERROR_NONE)
   4302           return result;
   4303         else if (!next) {
   4304           processor = ignoreSectionProcessor;
   4305           return result;
   4306         }
   4307       }
   4308       break;
   4309 #endif /* XML_DTD */
   4310     case XML_ROLE_GROUP_OPEN:
   4311       if (prologState.level >= groupSize) {
   4312         if (groupSize) {
   4313           char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);
   4314           if (temp == NULL)
   4315             return XML_ERROR_NO_MEMORY;
   4316           groupConnector = temp;
   4317           if (dtd->scaffIndex) {
   4318             int *temp = (int *)REALLOC(dtd->scaffIndex,
   4319                           groupSize * sizeof(int));
   4320             if (temp == NULL)
   4321               return XML_ERROR_NO_MEMORY;
   4322             dtd->scaffIndex = temp;
   4323           }
   4324         }
   4325         else {
   4326           groupConnector = (char *)MALLOC(groupSize = 32);
   4327           if (!groupConnector)
   4328             return XML_ERROR_NO_MEMORY;
   4329         }
   4330       }
   4331       groupConnector[prologState.level] = 0;
   4332       if (dtd->in_eldecl) {
   4333         int myindex = nextScaffoldPart(parser);
   4334         if (myindex < 0)
   4335           return XML_ERROR_NO_MEMORY;
   4336         dtd->scaffIndex[dtd->scaffLevel] = myindex;
   4337         dtd->scaffLevel++;
   4338         dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
   4339         if (elementDeclHandler)
   4340           handleDefault = XML_FALSE;
   4341       }
   4342       break;
   4343     case XML_ROLE_GROUP_SEQUENCE:
   4344       if (groupConnector[prologState.level] == ASCII_PIPE)
   4345         return XML_ERROR_SYNTAX;
   4346       groupConnector[prologState.level] = ASCII_COMMA;
   4347       if (dtd->in_eldecl && elementDeclHandler)
   4348         handleDefault = XML_FALSE;
   4349       break;
   4350     case XML_ROLE_GROUP_CHOICE:
   4351       if (groupConnector[prologState.level] == ASCII_COMMA)
   4352         return XML_ERROR_SYNTAX;
   4353       if (dtd->in_eldecl
   4354           && !groupConnector[prologState.level]
   4355           && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
   4356               != XML_CTYPE_MIXED)
   4357           ) {
   4358         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
   4359             = XML_CTYPE_CHOICE;
   4360         if (elementDeclHandler)
   4361           handleDefault = XML_FALSE;
   4362       }
   4363       groupConnector[prologState.level] = ASCII_PIPE;
   4364       break;
   4365     case XML_ROLE_PARAM_ENTITY_REF:
   4366 #ifdef XML_DTD
   4367     case XML_ROLE_INNER_PARAM_ENTITY_REF:
   4368       dtd->hasParamEntityRefs = XML_TRUE;
   4369       if (!paramEntityParsing)
   4370         dtd->keepProcessing = dtd->standalone;
   4371       else {
   4372         const XML_Char *name;
   4373         ENTITY *entity;
   4374         name = poolStoreString(&dtd->pool, enc,
   4375                                 s + enc->minBytesPerChar,
   4376                                 next - enc->minBytesPerChar);
   4377         if (!name)
   4378           return XML_ERROR_NO_MEMORY;
   4379         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
   4380         poolDiscard(&dtd->pool);
   4381         /* first, determine if a check for an existing declaration is needed;
   4382            if yes, check that the entity exists, and that it is internal,
   4383            otherwise call the skipped entity handler
   4384         */
   4385         if (prologState.documentEntity &&
   4386             (dtd->standalone
   4387              ? !openInternalEntities
   4388              : !dtd->hasParamEntityRefs)) {
   4389           if (!entity)
   4390             return XML_ERROR_UNDEFINED_ENTITY;
   4391           else if (!entity->is_internal)
   4392             return XML_ERROR_ENTITY_DECLARED_IN_PE;
   4393         }
   4394         else if (!entity) {
   4395           dtd->keepProcessing = dtd->standalone;
   4396           /* cannot report skipped entities in declarations */
   4397           if ((role == XML_ROLE_PARAM_ENTITY_REF) && skippedEntityHandler) {
   4398             skippedEntityHandler(handlerArg, name, 1);
   4399             handleDefault = XML_FALSE;
   4400           }
   4401           break;
   4402         }
   4403         if (entity->open)
   4404           return XML_ERROR_RECURSIVE_ENTITY_REF;
   4405         if (entity->textPtr) {
   4406           enum XML_Error result;
   4407           XML_Bool betweenDecl =
   4408             (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
   4409           result = processInternalEntity(parser, entity, betweenDecl);
   4410           if (result != XML_ERROR_NONE)
   4411             return result;
   4412           handleDefault = XML_FALSE;
   4413           break;
   4414         }
   4415         if (externalEntityRefHandler) {
   4416           dtd->paramEntityRead = XML_FALSE;
   4417           entity->open = XML_TRUE;
   4418           if (!externalEntityRefHandler(externalEntityRefHandlerArg,
   4419                                         0,
   4420                                         entity->base,
   4421                                         entity->systemId,
   4422                                         entity->publicId)) {
   4423             entity->open = XML_FALSE;
   4424             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
   4425           }
   4426           entity->open = XML_FALSE;
   4427           handleDefault = XML_FALSE;
   4428           if (!dtd->paramEntityRead) {
   4429             dtd->keepProcessing = dtd->standalone;
   4430             break;
   4431           }
   4432         }
   4433         else {
   4434           dtd->keepProcessing = dtd->standalone;
   4435           break;
   4436         }
   4437       }
   4438 #endif /* XML_DTD */
   4439       if (!dtd->standalone &&
   4440           notStandaloneHandler &&
   4441           !notStandaloneHandler(handlerArg))
   4442         return XML_ERROR_NOT_STANDALONE;
   4443       break;
   4444 
   4445     /* Element declaration stuff */
   4446 
   4447     case XML_ROLE_ELEMENT_NAME:
   4448       if (elementDeclHandler) {
   4449         declElementType = getElementType(parser, enc, s, next);
   4450         if (!declElementType)
   4451           return XML_ERROR_NO_MEMORY;
   4452         dtd->scaffLevel = 0;
   4453         dtd->scaffCount = 0;
   4454         dtd->in_eldecl = XML_TRUE;
   4455         handleDefault = XML_FALSE;
   4456       }
   4457       break;
   4458 
   4459     case XML_ROLE_CONTENT_ANY:
   4460     case XML_ROLE_CONTENT_EMPTY:
   4461       if (dtd->in_eldecl) {
   4462         if (elementDeclHandler) {
   4463           XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));
   4464           if (!content)
   4465             return XML_ERROR_NO_MEMORY;
   4466           content->quant = XML_CQUANT_NONE;
   4467           content->name = NULL;
   4468           content->numchildren = 0;
   4469           content->children = NULL;
   4470           content->type = ((role == XML_ROLE_CONTENT_ANY) ?
   4471                            XML_CTYPE_ANY :
   4472                            XML_CTYPE_EMPTY);
   4473           *eventEndPP = s;
   4474           elementDeclHandler(handlerArg, declElementType->name, content);
   4475           handleDefault = XML_FALSE;
   4476         }
   4477         dtd->in_eldecl = XML_FALSE;
   4478       }
   4479       break;
   4480 
   4481     case XML_ROLE_CONTENT_PCDATA:
   4482       if (dtd->in_eldecl) {
   4483         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
   4484             = XML_CTYPE_MIXED;
   4485         if (elementDeclHandler)
   4486           handleDefault = XML_FALSE;
   4487       }
   4488       break;
   4489 
   4490     case XML_ROLE_CONTENT_ELEMENT:
   4491       quant = XML_CQUANT_NONE;
   4492       goto elementContent;
   4493     case XML_ROLE_CONTENT_ELEMENT_OPT:
   4494       quant = XML_CQUANT_OPT;
   4495       goto elementContent;
   4496     case XML_ROLE_CONTENT_ELEMENT_REP:
   4497       quant = XML_CQUANT_REP;
   4498       goto elementContent;
   4499     case XML_ROLE_CONTENT_ELEMENT_PLUS:
   4500       quant = XML_CQUANT_PLUS;
   4501     elementContent:
   4502       if (dtd->in_eldecl) {
   4503         ELEMENT_TYPE *el;
   4504         const XML_Char *name;
   4505         int nameLen;
   4506         const char *nxt = (quant == XML_CQUANT_NONE
   4507                            ? next
   4508                            : next - enc->minBytesPerChar);
   4509         int myindex = nextScaffoldPart(parser);
   4510         if (myindex < 0)
   4511           return XML_ERROR_NO_MEMORY;
   4512         dtd->scaffold[myindex].type = XML_CTYPE_NAME;
   4513         dtd->scaffold[myindex].quant = quant;
   4514         el = getElementType(parser, enc, s, nxt);
   4515         if (!el)
   4516           return XML_ERROR_NO_MEMORY;
   4517         name = el->name;
   4518         dtd->scaffold[myindex].name = name;
   4519         nameLen = 0;
   4520         for (; name[nameLen++]; );
   4521         dtd->contentStringLen +=  nameLen;
   4522         if (elementDeclHandler)
   4523           handleDefault = XML_FALSE;
   4524       }
   4525       break;
   4526 
   4527     case XML_ROLE_GROUP_CLOSE:
   4528       quant = XML_CQUANT_NONE;
   4529       goto closeGroup;
   4530     case XML_ROLE_GROUP_CLOSE_OPT:
   4531       quant = XML_CQUANT_OPT;
   4532       goto closeGroup;
   4533     case XML_ROLE_GROUP_CLOSE_REP:
   4534       quant = XML_CQUANT_REP;
   4535       goto closeGroup;
   4536     case XML_ROLE_GROUP_CLOSE_PLUS:
   4537       quant = XML_CQUANT_PLUS;
   4538     closeGroup:
   4539       if (dtd->in_eldecl) {
   4540         if (elementDeclHandler)
   4541           handleDefault = XML_FALSE;
   4542         dtd->scaffLevel--;
   4543         dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
   4544         if (dtd->scaffLevel == 0) {
   4545           if (!handleDefault) {
   4546             XML_Content *model = build_model(parser);
   4547             if (!model)
   4548               return XML_ERROR_NO_MEMORY;
   4549             *eventEndPP = s;
   4550             elementDeclHandler(handlerArg, declElementType->name, model);
   4551           }
   4552           dtd->in_eldecl = XML_FALSE;
   4553           dtd->contentStringLen = 0;
   4554         }
   4555       }
   4556       break;
   4557       /* End element declaration stuff */
   4558 
   4559     case XML_ROLE_PI:
   4560       if (!reportProcessingInstruction(parser, enc, s, next))
   4561         return XML_ERROR_NO_MEMORY;
   4562       handleDefault = XML_FALSE;
   4563       break;
   4564     case XML_ROLE_COMMENT:
   4565       if (!reportComment(parser, enc, s, next))
   4566         return XML_ERROR_NO_MEMORY;
   4567       handleDefault = XML_FALSE;
   4568       break;
   4569     case XML_ROLE_NONE:
   4570       switch (tok) {
   4571       case XML_TOK_BOM:
   4572         handleDefault = XML_FALSE;
   4573         break;
   4574       }
   4575       break;
   4576     case XML_ROLE_DOCTYPE_NONE:
   4577       if (startDoctypeDeclHandler)
   4578         handleDefault = XML_FALSE;
   4579       break;
   4580     case XML_ROLE_ENTITY_NONE:
   4581       if (dtd->keepProcessing && entityDeclHandler)
   4582         handleDefault = XML_FALSE;
   4583       break;
   4584     case XML_ROLE_NOTATION_NONE:
   4585       if (notationDeclHandler)
   4586         handleDefault = XML_FALSE;
   4587       break;
   4588     case XML_ROLE_ATTLIST_NONE:
   4589       if (dtd->keepProcessing && attlistDeclHandler)
   4590         handleDefault = XML_FALSE;
   4591       break;
   4592     case XML_ROLE_ELEMENT_NONE:
   4593       if (elementDeclHandler)
   4594         handleDefault = XML_FALSE;
   4595       break;
   4596     } /* end of big switch */
   4597 
   4598     if (handleDefault && defaultHandler)
   4599       reportDefault(parser, enc, s, next);
   4600 
   4601     switch (ps_parsing) {
   4602     case XML_SUSPENDED:
   4603       *nextPtr = next;
   4604       return XML_ERROR_NONE;
   4605     case XML_FINISHED:
   4606       return XML_ERROR_ABORTED;
   4607     default:
   4608       s = next;
   4609       tok = XmlPrologTok(enc, s, end, &next);
   4610     }
   4611   }
   4612   /* not reached */
   4613 }
   4614 
   4615 static enum XML_Error PTRCALL
   4616 epilogProcessor(XML_Parser parser,
   4617                 const char *s,
   4618                 const char *end,
   4619                 const char **nextPtr)
   4620 {
   4621   processor = epilogProcessor;
   4622   eventPtr = s;
   4623   for (;;) {
   4624     const char *next = NULL;
   4625     int tok = XmlPrologTok(encoding, s, end, &next);
   4626     eventEndPtr = next;
   4627     switch (tok) {
   4628     /* report partial linebreak - it might be the last token */
   4629     case -XML_TOK_PROLOG_S:
   4630       if (defaultHandler) {
   4631         reportDefault(parser, encoding, s, next);
   4632         if (ps_parsing == XML_FINISHED)
   4633           return XML_ERROR_ABORTED;
   4634       }
   4635       *nextPtr = next;
   4636       return XML_ERROR_NONE;
   4637     case XML_TOK_NONE:
   4638       *nextPtr = s;
   4639       return XML_ERROR_NONE;
   4640     case XML_TOK_PROLOG_S:
   4641       if (defaultHandler)
   4642         reportDefault(parser, encoding, s, next);
   4643       break;
   4644     case XML_TOK_PI:
   4645       if (!reportProcessingInstruction(parser, encoding, s, next))
   4646         return XML_ERROR_NO_MEMORY;
   4647       break;
   4648     case XML_TOK_COMMENT:
   4649       if (!reportComment(parser, encoding, s, next))
   4650         return XML_ERROR_NO_MEMORY;
   4651       break;
   4652     case XML_TOK_INVALID:
   4653       eventPtr = next;
   4654       return XML_ERROR_INVALID_TOKEN;
   4655     case XML_TOK_PARTIAL:
   4656       if (!ps_finalBuffer) {
   4657         *nextPtr = s;
   4658         return XML_ERROR_NONE;
   4659       }
   4660       return XML_ERROR_UNCLOSED_TOKEN;
   4661     case XML_TOK_PARTIAL_CHAR:
   4662       if (!ps_finalBuffer) {
   4663         *nextPtr = s;
   4664         return XML_ERROR_NONE;
   4665       }
   4666       return XML_ERROR_PARTIAL_CHAR;
   4667     default:
   4668       return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
   4669     }
   4670     eventPtr = s = next;
   4671     switch (ps_parsing) {
   4672     case XML_SUSPENDED:
   4673       *nextPtr = next;
   4674       return XML_ERROR_NONE;
   4675     case XML_FINISHED:
   4676       return XML_ERROR_ABORTED;
   4677     default: ;
   4678     }
   4679   }
   4680 }
   4681 
   4682 static enum XML_Error
   4683 processInternalEntity(XML_Parser parser, ENTITY *entity,
   4684                       XML_Bool betweenDecl)
   4685 {
   4686   const char *textStart, *textEnd;
   4687   const char *next;
   4688   enum XML_Error result;
   4689   OPEN_INTERNAL_ENTITY *openEntity;
   4690 
   4691   if (freeInternalEntities) {
   4692     openEntity = freeInternalEntities;
   4693     freeInternalEntities = openEntity->next;
   4694   }
   4695   else {
   4696     openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));
   4697     if (!openEntity)
   4698       return XML_ERROR_NO_MEMORY;
   4699   }
   4700   entity->open = XML_TRUE;
   4701   entity->processed = 0;
   4702   openEntity->next = openInternalEntities;
   4703   openInternalEntities = openEntity;
   4704   openEntity->entity = entity;
   4705   openEntity->startTagLevel = tagLevel;
   4706   openEntity->betweenDecl = betweenDecl;
   4707   openEntity->internalEventPtr = NULL;
   4708   openEntity->internalEventEndPtr = NULL;
   4709   textStart = (char *)entity->textPtr;
   4710   textEnd = (char *)(entity->textPtr + entity->textLen);
   4711 
   4712 #ifdef XML_DTD
   4713   if (entity->is_param) {
   4714     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
   4715     result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
   4716                       next, &next, XML_FALSE);
   4717   }
   4718   else
   4719 #endif /* XML_DTD */
   4720     result = doContent(parser, tagLevel, internalEncoding, textStart,
   4721                        textEnd, &next, XML_FALSE);
   4722 
   4723   if (result == XML_ERROR_NONE) {
   4724     if (textEnd != next && ps_parsing == XML_SUSPENDED) {
   4725       entity->processed = (int)(next - textStart);
   4726       processor = internalEntityProcessor;
   4727     }
   4728     else {
   4729       entity->open = XML_FALSE;
   4730       openInternalEntities = openEntity->next;
   4731       /* put openEntity back in list of free instances */
   4732       openEntity->next = freeInternalEntities;
   4733       freeInternalEntities = openEntity;
   4734     }
   4735   }
   4736   return result;
   4737 }
   4738 
   4739 static enum XML_Error PTRCALL
   4740 internalEntityProcessor(XML_Parser parser,
   4741                         const char *s,
   4742                         const char *end,
   4743                         const char **nextPtr)
   4744 {
   4745   ENTITY *entity;
   4746   const char *textStart, *textEnd;
   4747   const char *next;
   4748   enum XML_Error result;
   4749   OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;
   4750   if (!openEntity)
   4751     return XML_ERROR_UNEXPECTED_STATE;
   4752 
   4753   entity = openEntity->entity;
   4754   textStart = ((char *)entity->textPtr) + entity->processed;
   4755   textEnd = (char *)(entity->textPtr + entity->textLen);
   4756 
   4757 #ifdef XML_DTD
   4758   if (entity->is_param) {
   4759     int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
   4760     result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
   4761                       next, &next, XML_FALSE);
   4762   }
   4763   else
   4764 #endif /* XML_DTD */
   4765     result = doContent(parser, openEntity->startTagLevel, internalEncoding,
   4766                        textStart, textEnd, &next, XML_FALSE);
   4767 
   4768   if (result != XML_ERROR_NONE)
   4769     return result;
   4770   else if (textEnd != next && ps_parsing == XML_SUSPENDED) {
   4771     entity->processed = (int)(next - (char *)entity->textPtr);
   4772     return result;
   4773   }
   4774   else {
   4775     entity->open = XML_FALSE;
   4776     openInternalEntities = openEntity->next;
   4777     /* put openEntity back in list of free instances */
   4778     openEntity->next = freeInternalEntities;
   4779     freeInternalEntities = openEntity;
   4780   }
   4781 
   4782 #ifdef XML_DTD
   4783   if (entity->is_param) {
   4784     int tok;
   4785     processor = prologProcessor;
   4786     tok = XmlPrologTok(encoding, s, end, &next);
   4787     return doProlog(parser, encoding, s, end, tok, next, nextPtr,
   4788                     (XML_Bool)!ps_finalBuffer);
   4789   }
   4790   else
   4791 #endif /* XML_DTD */
   4792   {
   4793     processor = contentProcessor;
   4794     /* see externalEntityContentProcessor vs contentProcessor */
   4795     return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
   4796                      nextPtr, (XML_Bool)!ps_finalBuffer);
   4797   }
   4798 }
   4799 
   4800 static enum XML_Error PTRCALL
   4801 errorProcessor(XML_Parser parser,
   4802                const char *s,
   4803                const char *end,
   4804                const char **nextPtr)
   4805 {
   4806   return errorCode;
   4807 }
   4808 
   4809 static enum XML_Error
   4810 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
   4811                     const char *ptr, const char *end,
   4812                     STRING_POOL *pool)
   4813 {
   4814   enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,
   4815                                                end, pool);
   4816   if (result)
   4817     return result;
   4818   if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
   4819     poolChop(pool);
   4820   if (!poolAppendChar(pool, XML_T('\0')))
   4821     return XML_ERROR_NO_MEMORY;
   4822   return XML_ERROR_NONE;
   4823 }
   4824 
   4825 static enum XML_Error
   4826 appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
   4827                      const char *ptr, const char *end,
   4828                      STRING_POOL *pool)
   4829 {
   4830   DTD * const dtd = _dtd;  /* save one level of indirection */
   4831   for (;;) {
   4832     const char *next;
   4833     int tok = XmlAttributeValueTok(enc, ptr, end, &next);
   4834     switch (tok) {
   4835     case XML_TOK_NONE:
   4836       return XML_ERROR_NONE;
   4837     case XML_TOK_INVALID:
   4838       if (enc == encoding)
   4839         eventPtr = next;
   4840       return XML_ERROR_INVALID_TOKEN;
   4841     case XML_TOK_PARTIAL:
   4842       if (enc == encoding)
   4843         eventPtr = ptr;
   4844       return XML_ERROR_INVALID_TOKEN;
   4845     case XML_TOK_CHAR_REF:
   4846       {
   4847         XML_Char buf[XML_ENCODE_MAX];
   4848         int i;
   4849         int n = XmlCharRefNumber(enc, ptr);
   4850         if (n < 0) {
   4851           if (enc == encoding)
   4852             eventPtr = ptr;
   4853           return XML_ERROR_BAD_CHAR_REF;
   4854         }
   4855         if (!isCdata
   4856             && n == 0x20 /* space */
   4857             && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
   4858           break;
   4859         n = XmlEncode(n, (ICHAR *)buf);
   4860         if (!n) {
   4861           if (enc == encoding)
   4862             eventPtr = ptr;
   4863           return XML_ERROR_BAD_CHAR_REF;
   4864         }
   4865         for (i = 0; i < n; i++) {
   4866           if (!poolAppendChar(pool, buf[i]))
   4867             return XML_ERROR_NO_MEMORY;
   4868         }
   4869       }
   4870       break;
   4871     case XML_TOK_DATA_CHARS:
   4872       if (!poolAppend(pool, enc, ptr, next))
   4873         return XML_ERROR_NO_MEMORY;
   4874       break;
   4875     case XML_TOK_TRAILING_CR:
   4876       next = ptr + enc->minBytesPerChar;
   4877       /* fall through */
   4878     case XML_TOK_ATTRIBUTE_VALUE_S:
   4879     case XML_TOK_DATA_NEWLINE:
   4880       if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
   4881         break;
   4882       if (!poolAppendChar(pool, 0x20))
   4883         return XML_ERROR_NO_MEMORY;
   4884       break;
   4885     case XML_TOK_ENTITY_REF:
   4886       {
   4887         const XML_Char *name;
   4888         ENTITY *entity;
   4889         char checkEntityDecl;
   4890         XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
   4891                                               ptr + enc->minBytesPerChar,
   4892                                               next - enc->minBytesPerChar);
   4893         if (ch) {
   4894           if (!poolAppendChar(pool, ch))
   4895                 return XML_ERROR_NO_MEMORY;
   4896           break;
   4897         }
   4898         name = poolStoreString(&temp2Pool, enc,
   4899                                ptr + enc->minBytesPerChar,
   4900                                next - enc->minBytesPerChar);
   4901         if (!name)
   4902           return XML_ERROR_NO_MEMORY;
   4903         entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
   4904         poolDiscard(&temp2Pool);
   4905         /* First, determine if a check for an existing declaration is needed;
   4906            if yes, check that the entity exists, and that it is internal.
   4907         */
   4908         if (pool == &dtd->pool)  /* are we called from prolog? */
   4909           checkEntityDecl =
   4910 #ifdef XML_DTD
   4911               prologState.documentEntity &&
   4912 #endif /* XML_DTD */
   4913               (dtd->standalone
   4914                ? !openInternalEntities
   4915                : !dtd->hasParamEntityRefs);
   4916         else /* if (pool == &tempPool): we are called from content */
   4917           checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;
   4918         if (checkEntityDecl) {
   4919           if (!entity)
   4920             return XML_ERROR_UNDEFINED_ENTITY;
   4921           else if (!entity->is_internal)
   4922             return XML_ERROR_ENTITY_DECLARED_IN_PE;
   4923         }
   4924         else if (!entity) {
   4925           /* Cannot report skipped entity here - see comments on
   4926              skippedEntityHandler.
   4927           if (skippedEntityHandler)
   4928             skippedEntityHandler(handlerArg, name, 0);
   4929           */
   4930           /* Cannot call the default handler because this would be
   4931              out of sync with the call to the startElementHandler.
   4932           if ((pool == &tempPool) && defaultHandler)
   4933             reportDefault(parser, enc, ptr, next);
   4934           */
   4935           break;
   4936         }
   4937         if (entity->open) {
   4938           if (enc == encoding)
   4939             eventPtr = ptr;
   4940           return XML_ERROR_RECURSIVE_ENTITY_REF;
   4941         }
   4942         if (entity->notation) {
   4943           if (enc == encoding)
   4944             eventPtr = ptr;
   4945           return XML_ERROR_BINARY_ENTITY_REF;
   4946         }
   4947         if (!entity->textPtr) {
   4948           if (enc == encoding)
   4949             eventPtr = ptr;
   4950               return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
   4951         }
   4952         else {
   4953           enum XML_Error result;
   4954           const XML_Char *textEnd = entity->textPtr + entity->textLen;
   4955           entity->open = XML_TRUE;
   4956           result = appendAttributeValue(parser, internalEncoding, isCdata,
   4957                                         (char *)entity->textPtr,
   4958                                         (char *)textEnd, pool);
   4959           entity->open = XML_FALSE;
   4960           if (result)
   4961             return result;
   4962         }
   4963       }
   4964       break;
   4965     default:
   4966       if (enc == encoding)
   4967         eventPtr = ptr;
   4968       return XML_ERROR_UNEXPECTED_STATE;
   4969     }
   4970     ptr = next;
   4971   }
   4972   /* not reached */
   4973 }
   4974 
   4975 static enum XML_Error
   4976 storeEntityValue(XML_Parser parser,
   4977                  const ENCODING *enc,
   4978                  const char *entityTextPtr,
   4979                  const char *entityTextEnd)
   4980 {
   4981   DTD * const dtd = _dtd;  /* save one level of indirection */
   4982   STRING_POOL *pool = &(dtd->entityValuePool);
   4983   enum XML_Error result = XML_ERROR_NONE;
   4984 #ifdef XML_DTD
   4985   int oldInEntityValue = prologState.inEntityValue;
   4986   prologState.inEntityValue = 1;
   4987 #endif /* XML_DTD */
   4988   /* never return Null for the value argument in EntityDeclHandler,
   4989      since this would indicate an external entity; therefore we
   4990      have to make sure that entityValuePool.start is not null */
   4991   if (!pool->blocks) {
   4992     if (!poolGrow(pool))
   4993       return XML_ERROR_NO_MEMORY;
   4994   }
   4995 
   4996   for (;;) {
   4997     const char *next;
   4998     int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
   4999     switch (tok) {
   5000     case XML_TOK_PARAM_ENTITY_REF:
   5001 #ifdef XML_DTD
   5002       if (isParamEntity || enc != encoding) {
   5003         const XML_Char *name;
   5004         ENTITY *entity;
   5005         name = poolStoreString(&tempPool, enc,
   5006                                entityTextPtr + enc->minBytesPerChar,
   5007                                next - enc->minBytesPerChar);
   5008         if (!name) {
   5009           result = XML_ERROR_NO_MEMORY;
   5010           goto endEntityValue;
   5011         }
   5012         entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
   5013         poolDiscard(&tempPool);
   5014         if (!entity) {
   5015           /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
   5016           /* cannot report skipped entity here - see comments on
   5017              skippedEntityHandler
   5018           if (skippedEntityHandler)
   5019             skippedEntityHandler(handlerArg, name, 0);
   5020           */
   5021           dtd->keepProcessing = dtd->standalone;
   5022           goto endEntityValue;
   5023         }
   5024         if (entity->open) {
   5025           if (enc == encoding)
   5026             eventPtr = entityTextPtr;
   5027           result = XML_ERROR_RECURSIVE_ENTITY_REF;
   5028           goto endEntityValue;
   5029         }
   5030         if (entity->systemId) {
   5031           if (externalEntityRefHandler) {
   5032             dtd->paramEntityRead = XML_FALSE;
   5033             entity->open = XML_TRUE;
   5034             if (!externalEntityRefHandler(externalEntityRefHandlerArg,
   5035                                           0,
   5036                                           entity->base,
   5037                                           entity->systemId,
   5038                                           entity->publicId)) {
   5039               entity->open = XML_FALSE;
   5040               result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
   5041               goto endEntityValue;
   5042             }
   5043             entity->open = XML_FALSE;
   5044             if (!dtd->paramEntityRead)
   5045               dtd->keepProcessing = dtd->standalone;
   5046           }
   5047           else
   5048             dtd->keepProcessing = dtd->standalone;
   5049         }
   5050         else {
   5051           entity->open = XML_TRUE;
   5052           result = storeEntityValue(parser,
   5053                                     internalEncoding,
   5054                                     (char *)entity->textPtr,
   5055                                     (char *)(entity->textPtr
   5056                                              + entity->textLen));
   5057           entity->open = XML_FALSE;
   5058           if (result)
   5059             goto endEntityValue;
   5060         }
   5061         break;
   5062       }
   5063 #endif /* XML_DTD */
   5064       /* In the internal subset, PE references are not legal
   5065          within markup declarations, e.g entity values in this case. */
   5066       eventPtr = entityTextPtr;
   5067       result = XML_ERROR_PARAM_ENTITY_REF;
   5068       goto endEntityValue;
   5069     case XML_TOK_NONE:
   5070       result = XML_ERROR_NONE;
   5071       goto endEntityValue;
   5072     case XML_TOK_ENTITY_REF:
   5073     case XML_TOK_DATA_CHARS:
   5074       if (!poolAppend(pool, enc, entityTextPtr, next)) {
   5075         result = XML_ERROR_NO_MEMORY;
   5076         goto endEntityValue;
   5077       }
   5078       break;
   5079     case XML_TOK_TRAILING_CR:
   5080       next = entityTextPtr + enc->minBytesPerChar;
   5081       /* fall through */
   5082     case XML_TOK_DATA_NEWLINE:
   5083       if (pool->end == pool->ptr && !poolGrow(pool)) {
   5084               result = XML_ERROR_NO_MEMORY;
   5085         goto endEntityValue;
   5086       }
   5087       *(pool->ptr)++ = 0xA;
   5088       break;
   5089     case XML_TOK_CHAR_REF:
   5090       {
   5091         XML_Char buf[XML_ENCODE_MAX];
   5092         int i;
   5093         int n = XmlCharRefNumber(enc, entityTextPtr);
   5094         if (n < 0) {
   5095           if (enc == encoding)
   5096             eventPtr = entityTextPtr;
   5097           result = XML_ERROR_BAD_CHAR_REF;
   5098           goto endEntityValue;
   5099         }
   5100         n = XmlEncode(n, (ICHAR *)buf);
   5101         if (!n) {
   5102           if (enc == encoding)
   5103             eventPtr = entityTextPtr;
   5104           result = XML_ERROR_BAD_CHAR_REF;
   5105           goto endEntityValue;
   5106         }
   5107         for (i = 0; i < n; i++) {
   5108           if (pool->end == pool->ptr && !poolGrow(pool)) {
   5109             result = XML_ERROR_NO_MEMORY;
   5110             goto endEntityValue;
   5111           }
   5112           *(pool->ptr)++ = buf[i];
   5113         }
   5114       }
   5115       break;
   5116     case XML_TOK_PARTIAL:
   5117       if (enc == encoding)
   5118         eventPtr = entityTextPtr;
   5119       result = XML_ERROR_INVALID_TOKEN;
   5120       goto endEntityValue;
   5121     case XML_TOK_INVALID:
   5122       if (enc == encoding)
   5123         eventPtr = next;
   5124       result = XML_ERROR_INVALID_TOKEN;
   5125       goto endEntityValue;
   5126     default:
   5127       if (enc == encoding)
   5128         eventPtr = entityTextPtr;
   5129       result = XML_ERROR_UNEXPECTED_STATE;
   5130       goto endEntityValue;
   5131     }
   5132     entityTextPtr = next;
   5133   }
   5134 endEntityValue:
   5135 #ifdef XML_DTD
   5136   prologState.inEntityValue = oldInEntityValue;
   5137 #endif /* XML_DTD */
   5138   return result;
   5139 }
   5140 
   5141 static void FASTCALL
   5142 normalizeLines(XML_Char *s)
   5143 {
   5144   XML_Char *p;
   5145   for (;; s++) {
   5146     if (*s == XML_T('\0'))
   5147       return;
   5148     if (*s == 0xD)
   5149       break;
   5150   }
   5151   p = s;
   5152   do {
   5153     if (*s == 0xD) {
   5154       *p++ = 0xA;
   5155       if (*++s == 0xA)
   5156         s++;
   5157     }
   5158     else
   5159       *p++ = *s++;
   5160   } while (*s);
   5161   *p = XML_T('\0');
   5162 }
   5163 
   5164 static int
   5165 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
   5166                             const char *start, const char *end)
   5167 {
   5168   const XML_Char *target;
   5169   XML_Char *data;
   5170   const char *tem;
   5171   if (!processingInstructionHandler) {
   5172     if (defaultHandler)
   5173       reportDefault(parser, enc, start, end);
   5174     return 1;
   5175   }
   5176   start += enc->minBytesPerChar * 2;
   5177   tem = start + XmlNameLength(enc, start);
   5178   target = poolStoreString(&tempPool, enc, start, tem);
   5179   if (!target)
   5180     return 0;
   5181   poolFinish(&tempPool);
   5182   data = poolStoreString(&tempPool, enc,
   5183                         XmlSkipS(enc, tem),
   5184                         end - enc->minBytesPerChar*2);
   5185   if (!data)
   5186     return 0;
   5187   normalizeLines(data);
   5188   processingInstructionHandler(handlerArg, target, data);
   5189   poolClear(&tempPool);
   5190   return 1;
   5191 }
   5192 
   5193 static int
   5194 reportComment(XML_Parser parser, const ENCODING *enc,
   5195               const char *start, const char *end)
   5196 {
   5197   XML_Char *data;
   5198   if (!commentHandler) {
   5199     if (defaultHandler)
   5200       reportDefault(parser, enc, start, end);
   5201     return 1;
   5202   }
   5203   data = poolStoreString(&tempPool,
   5204                          enc,
   5205                          start + enc->minBytesPerChar * 4,
   5206                          end - enc->minBytesPerChar * 3);
   5207   if (!data)
   5208     return 0;
   5209   normalizeLines(data);
   5210   commentHandler(handlerArg, data);
   5211   poolClear(&tempPool);
   5212   return 1;
   5213 }
   5214 
   5215 static void
   5216 reportDefault(XML_Parser parser, const ENCODING *enc,
   5217               const char *s, const char *end)
   5218 {
   5219   if (MUST_CONVERT(enc, s)) {
   5220     const char **eventPP;
   5221     const char **eventEndPP;
   5222     if (enc == encoding) {
   5223       eventPP = &eventPtr;
   5224       eventEndPP = &eventEndPtr;
   5225     }
   5226     else {
   5227       eventPP = &(openInternalEntities->internalEventPtr);
   5228       eventEndPP = &(openInternalEntities->internalEventEndPtr);
   5229     }
   5230     do {
   5231       ICHAR *dataPtr = (ICHAR *)dataBuf;
   5232       XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
   5233       *eventEndPP = s;
   5234       defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
   5235       *eventPP = s;
   5236     } while (s != end);
   5237   }
   5238   else
   5239     defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
   5240 }
   5241 
   5242 
   5243 static int
   5244 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
   5245                 XML_Bool isId, const XML_Char *value, XML_Parser parser)
   5246 {
   5247   DEFAULT_ATTRIBUTE *att;
   5248   if (value || isId) {
   5249     /* The handling of default attributes gets messed up if we have
   5250        a default which duplicates a non-default. */
   5251     int i;
   5252     for (i = 0; i < type->nDefaultAtts; i++)
   5253       if (attId == type->defaultAtts[i].id)
   5254         return 1;
   5255     if (isId && !type->idAtt && !attId->xmlns)
   5256       type->idAtt = attId;
   5257   }
   5258   if (type->nDefaultAtts == type->allocDefaultAtts) {
   5259     if (type->allocDefaultAtts == 0) {
   5260       type->allocDefaultAtts = 8;
   5261       type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts
   5262                             * sizeof(DEFAULT_ATTRIBUTE));
   5263       if (!type->defaultAtts)
   5264         return 0;
   5265     }
   5266     else {
   5267       DEFAULT_ATTRIBUTE *temp;
   5268       int count = type->allocDefaultAtts * 2;
   5269       temp = (DEFAULT_ATTRIBUTE *)
   5270         REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
   5271       if (temp == NULL)
   5272         return 0;
   5273       type->allocDefaultAtts = count;
   5274       type->defaultAtts = temp;
   5275     }
   5276   }
   5277   att = type->defaultAtts + type->nDefaultAtts;
   5278   att->id = attId;
   5279   att->value = value;
   5280   att->isCdata = isCdata;
   5281   if (!isCdata)
   5282     attId->maybeTokenized = XML_TRUE;
   5283   type->nDefaultAtts += 1;
   5284   return 1;
   5285 }
   5286 
   5287 static int
   5288 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
   5289 {
   5290   DTD * const dtd = _dtd;  /* save one level of indirection */
   5291   const XML_Char *name;
   5292   for (name = elementType->name; *name; name++) {
   5293     if (*name == XML_T(ASCII_COLON)) {
   5294       PREFIX *prefix;
   5295       const XML_Char *s;
   5296       for (s = elementType->name; s != name; s++) {
   5297         if (!poolAppendChar(&dtd->pool, *s))
   5298           return 0;
   5299       }
   5300       if (!poolAppendChar(&dtd->pool, XML_T('\0')))
   5301         return 0;
   5302       prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
   5303                                 sizeof(PREFIX));
   5304       if (!prefix)
   5305         return 0;
   5306       if (prefix->name == poolStart(&dtd->pool))
   5307         poolFinish(&dtd->pool);
   5308       else
   5309         poolDiscard(&dtd->pool);
   5310       elementType->prefix = prefix;
   5311 
   5312     }
   5313   }
   5314   return 1;
   5315 }
   5316 
   5317 static ATTRIBUTE_ID *
   5318 getAttributeId(XML_Parser parser, const ENCODING *enc,
   5319                const char *start, const char *end)
   5320 {
   5321   DTD * const dtd = _dtd;  /* save one level of indirection */
   5322   ATTRIBUTE_ID *id;
   5323   const XML_Char *name;
   5324   if (!poolAppendChar(&dtd->pool, XML_T('\0')))
   5325     return NULL;
   5326   name = poolStoreString(&dtd->pool, enc, start, end);
   5327   if (!name)
   5328     return NULL;
   5329   /* skip quotation mark - its storage will be re-used (like in name[-1]) */
   5330   ++name;
   5331   id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
   5332   if (!id)
   5333     return NULL;
   5334   if (id->name != name)
   5335     poolDiscard(&dtd->pool);
   5336   else {
   5337     poolFinish(&dtd->pool);
   5338     if (!ns)
   5339       ;
   5340     else if (name[0] == XML_T(ASCII_x)
   5341         && name[1] == XML_T(ASCII_m)
   5342         && name[2] == XML_T(ASCII_l)
   5343         && name[3] == XML_T(ASCII_n)
   5344         && name[4] == XML_T(ASCII_s)
   5345         && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
   5346       if (name[5] == XML_T('\0'))
   5347         id->prefix = &dtd->defaultPrefix;
   5348       else
   5349         id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));
   5350       id->xmlns = XML_TRUE;
   5351     }
   5352     else {
   5353       int i;
   5354       for (i = 0; name[i]; i++) {
   5355         /* attributes without prefix are *not* in the default namespace */
   5356         if (name[i] == XML_T(ASCII_COLON)) {
   5357           int j;
   5358           for (j = 0; j < i; j++) {
   5359             if (!poolAppendChar(&dtd->pool, name[j]))
   5360               return NULL;
   5361           }
   5362           if (!poolAppendChar(&dtd->pool, XML_T('\0')))
   5363             return NULL;
   5364           id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),
   5365                                         sizeof(PREFIX));
   5366           if (id->prefix->name == poolStart(&dtd->pool))
   5367             poolFinish(&dtd->pool);
   5368           else
   5369             poolDiscard(&dtd->pool);
   5370           break;
   5371         }
   5372       }
   5373     }
   5374   }
   5375   return id;
   5376 }
   5377 
   5378 #define CONTEXT_SEP XML_T(ASCII_FF)
   5379 
   5380 static const XML_Char *
   5381 getContext(XML_Parser parser)
   5382 {
   5383   DTD * const dtd = _dtd;  /* save one level of indirection */
   5384   HASH_TABLE_ITER iter;
   5385   XML_Bool needSep = XML_FALSE;
   5386 
   5387   if (dtd->defaultPrefix.binding) {
   5388     int i;
   5389     int len;
   5390     if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
   5391       return NULL;
   5392     len = dtd->defaultPrefix.binding->uriLen;
   5393     if (namespaceSeparator)
   5394       len--;
   5395     for (i = 0; i < len; i++)
   5396       if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))
   5397         return NULL;
   5398     needSep = XML_TRUE;
   5399   }
   5400 
   5401   hashTableIterInit(&iter, &(dtd->prefixes));
   5402   for (;;) {
   5403     int i;
   5404     int len;
   5405     const XML_Char *s;
   5406     PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
   5407     if (!prefix)
   5408       break;
   5409     if (!prefix->binding)
   5410       continue;
   5411     if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
   5412       return NULL;
   5413     for (s = prefix->name; *s; s++)
   5414       if (!poolAppendChar(&tempPool, *s))
   5415         return NULL;
   5416     if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
   5417       return NULL;
   5418     len = prefix->binding->uriLen;
   5419     if (namespaceSeparator)
   5420       len--;
   5421     for (i = 0; i < len; i++)
   5422       if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
   5423         return NULL;
   5424     needSep = XML_TRUE;
   5425   }
   5426 
   5427 
   5428   hashTableIterInit(&iter, &(dtd->generalEntities));
   5429   for (;;) {
   5430     const XML_Char *s;
   5431     ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
   5432     if (!e)
   5433       break;
   5434     if (!e->open)
   5435       continue;
   5436     if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
   5437       return NULL;
   5438     for (s = e->name; *s; s++)
   5439       if (!poolAppendChar(&tempPool, *s))
   5440         return 0;
   5441     needSep = XML_TRUE;
   5442   }
   5443 
   5444   if (!poolAppendChar(&tempPool, XML_T('\0')))
   5445     return NULL;
   5446   return tempPool.start;
   5447 }
   5448 
   5449 static XML_Bool
   5450 setContext(XML_Parser parser, const XML_Char *context)
   5451 {
   5452   DTD * const dtd = _dtd;  /* save one level of indirection */
   5453   const XML_Char *s = context;
   5454 
   5455   while (*context != XML_T('\0')) {
   5456     if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
   5457       ENTITY *e;
   5458       if (!poolAppendChar(&tempPool, XML_T('\0')))
   5459         return XML_FALSE;
   5460       e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);
   5461       if (e)
   5462         e->open = XML_TRUE;
   5463       if (*s != XML_T('\0'))
   5464         s++;
   5465       context = s;
   5466       poolDiscard(&tempPool);
   5467     }
   5468     else if (*s == XML_T(ASCII_EQUALS)) {
   5469       PREFIX *prefix;
   5470       if (poolLength(&tempPool) == 0)
   5471         prefix = &dtd->defaultPrefix;
   5472       else {
   5473         if (!poolAppendChar(&tempPool, XML_T('\0')))
   5474           return XML_FALSE;
   5475         prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),
   5476                                   sizeof(PREFIX));
   5477         if (!prefix)
   5478           return XML_FALSE;
   5479         if (prefix->name == poolStart(&tempPool)) {
   5480           prefix->name = poolCopyString(&dtd->pool, prefix->name);
   5481           if (!prefix->name)
   5482             return XML_FALSE;
   5483         }
   5484         poolDiscard(&tempPool);
   5485       }
   5486       for (context = s + 1;
   5487            *context != CONTEXT_SEP && *context != XML_T('\0');
   5488            context++)
   5489         if (!poolAppendChar(&tempPool, *context))
   5490           return XML_FALSE;
   5491       if (!poolAppendChar(&tempPool, XML_T('\0')))
   5492         return XML_FALSE;
   5493       if (addBinding(parser, prefix, NULL, poolStart(&tempPool),
   5494                      &inheritedBindings) != XML_ERROR_NONE)
   5495         return XML_FALSE;
   5496       poolDiscard(&tempPool);
   5497       if (*context != XML_T('\0'))
   5498         ++context;
   5499       s = context;
   5500     }
   5501     else {
   5502       if (!poolAppendChar(&tempPool, *s))
   5503         return XML_FALSE;
   5504       s++;
   5505     }
   5506   }
   5507   return XML_TRUE;
   5508 }
   5509 
   5510 static void FASTCALL
   5511 normalizePublicId(XML_Char *publicId)
   5512 {
   5513   XML_Char *p = publicId;
   5514   XML_Char *s;
   5515   for (s = publicId; *s; s++) {
   5516     switch (*s) {
   5517     case 0x20:
   5518     case 0xD:
   5519     case 0xA:
   5520       if (p != publicId && p[-1] != 0x20)
   5521         *p++ = 0x20;
   5522       break;
   5523     default:
   5524       *p++ = *s;
   5525     }
   5526   }
   5527   if (p != publicId && p[-1] == 0x20)
   5528     --p;
   5529   *p = XML_T('\0');
   5530 }
   5531 
   5532 static DTD *
   5533 dtdCreate(const XML_Memory_Handling_Suite *ms)
   5534 {
   5535   DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
   5536   if (p == NULL)
   5537     return p;
   5538   poolInit(&(p->pool), ms);
   5539   poolInit(&(p->entityValuePool), ms);
   5540   hashTableInit(&(p->generalEntities), ms);
   5541   hashTableInit(&(p->elementTypes), ms);
   5542   hashTableInit(&(p->attributeIds), ms);
   5543   hashTableInit(&(p->prefixes), ms);
   5544 #ifdef XML_DTD
   5545   p->paramEntityRead = XML_FALSE;
   5546   hashTableInit(&(p->paramEntities), ms);
   5547 #endif /* XML_DTD */
   5548   p->defaultPrefix.name = NULL;
   5549   p->defaultPrefix.binding = NULL;
   5550 
   5551   p->in_eldecl = XML_FALSE;
   5552   p->scaffIndex = NULL;
   5553   p->scaffold = NULL;
   5554   p->scaffLevel = 0;
   5555   p->scaffSize = 0;
   5556   p->scaffCount = 0;
   5557   p->contentStringLen = 0;
   5558 
   5559   p->keepProcessing = XML_TRUE;
   5560   p->hasParamEntityRefs = XML_FALSE;
   5561   p->standalone = XML_FALSE;
   5562   return p;
   5563 }
   5564 
   5565 static void
   5566 dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)
   5567 {
   5568   HASH_TABLE_ITER iter;
   5569   hashTableIterInit(&iter, &(p->elementTypes));
   5570   for (;;) {
   5571     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
   5572     if (!e)
   5573       break;
   5574     if (e->allocDefaultAtts != 0)
   5575       ms->free_fcn(e->defaultAtts);
   5576   }
   5577   hashTableClear(&(p->generalEntities));
   5578 #ifdef XML_DTD
   5579   p->paramEntityRead = XML_FALSE;
   5580   hashTableClear(&(p->paramEntities));
   5581 #endif /* XML_DTD */
   5582   hashTableClear(&(p->elementTypes));
   5583   hashTableClear(&(p->attributeIds));
   5584   hashTableClear(&(p->prefixes));
   5585   poolClear(&(p->pool));
   5586   poolClear(&(p->entityValuePool));
   5587   p->defaultPrefix.name = NULL;
   5588   p->defaultPrefix.binding = NULL;
   5589 
   5590   p->in_eldecl = XML_FALSE;
   5591 
   5592   ms->free_fcn(p->scaffIndex);
   5593   p->scaffIndex = NULL;
   5594   ms->free_fcn(p->scaffold);
   5595   p->scaffold = NULL;
   5596 
   5597   p->scaffLevel = 0;
   5598   p->scaffSize = 0;
   5599   p->scaffCount = 0;
   5600   p->contentStringLen = 0;
   5601 
   5602   p->keepProcessing = XML_TRUE;
   5603   p->hasParamEntityRefs = XML_FALSE;
   5604   p->standalone = XML_FALSE;
   5605 }
   5606 
   5607 static void
   5608 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)
   5609 {
   5610   HASH_TABLE_ITER iter;
   5611   hashTableIterInit(&iter, &(p->elementTypes));
   5612   for (;;) {
   5613     ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
   5614     if (!e)
   5615       break;
   5616     if (e->allocDefaultAtts != 0)
   5617       ms->free_fcn(e->defaultAtts);
   5618   }
   5619   hashTableDestroy(&(p->generalEntities));
   5620 #ifdef XML_DTD
   5621   hashTableDestroy(&(p->paramEntities));
   5622 #endif /* XML_DTD */
   5623   hashTableDestroy(&(p->elementTypes));
   5624   hashTableDestroy(&(p->attributeIds));
   5625   hashTableDestroy(&(p->prefixes));
   5626   poolDestroy(&(p->pool));
   5627   poolDestroy(&(p->entityValuePool));
   5628   if (isDocEntity) {
   5629     ms->free_fcn(p->scaffIndex);
   5630     ms->free_fcn(p->scaffold);
   5631   }
   5632   ms->free_fcn(p);
   5633 }
   5634 
   5635 /* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
   5636    The new DTD has already been initialized.
   5637 */
   5638 static int
   5639 dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms)
   5640 {
   5641   HASH_TABLE_ITER iter;
   5642 
   5643   /* Copy the prefix table. */
   5644 
   5645   hashTableIterInit(&iter, &(oldDtd->prefixes));
   5646   for (;;) {
   5647     const XML_Char *name;
   5648     const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
   5649     if (!oldP)
   5650       break;
   5651     name = poolCopyString(&(newDtd->pool), oldP->name);
   5652     if (!name)
   5653       return 0;
   5654     if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
   5655       return 0;
   5656   }
   5657 
   5658   hashTableIterInit(&iter, &(oldDtd->attributeIds));
   5659 
   5660   /* Copy the attribute id table. */
   5661 
   5662   for (;;) {
   5663     ATTRIBUTE_ID *newA;
   5664     const XML_Char *name;
   5665     const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
   5666 
   5667     if (!oldA)
   5668       break;
   5669     /* Remember to allocate the scratch byte before the name. */
   5670     if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
   5671       return 0;
   5672     name = poolCopyString(&(newDtd->pool), oldA->name);
   5673     if (!name)
   5674       return 0;
   5675     ++name;
   5676     newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,
   5677                                   sizeof(ATTRIBUTE_ID));
   5678     if (!newA)
   5679       return 0;
   5680     newA->maybeTokenized = oldA->maybeTokenized;
   5681     if (oldA->prefix) {
   5682       newA->xmlns = oldA->xmlns;
   5683       if (oldA->prefix == &oldDtd->defaultPrefix)
   5684         newA->prefix = &newDtd->defaultPrefix;
   5685       else
   5686         newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
   5687                                         oldA->prefix->name, 0);
   5688     }
   5689   }
   5690 
   5691   /* Copy the element type table. */
   5692 
   5693   hashTableIterInit(&iter, &(oldDtd->elementTypes));
   5694 
   5695   for (;;) {
   5696     int i;
   5697     ELEMENT_TYPE *newE;
   5698     const XML_Char *name;
   5699     const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
   5700     if (!oldE)
   5701       break;
   5702     name = poolCopyString(&(newDtd->pool), oldE->name);
   5703     if (!name)
   5704       return 0;
   5705     newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,
   5706                                   sizeof(ELEMENT_TYPE));
   5707     if (!newE)
   5708       return 0;
   5709     if (oldE->nDefaultAtts) {
   5710       newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
   5711           ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
   5712       if (!newE->defaultAtts) {
   5713         ms->free_fcn(newE);
   5714         return 0;
   5715       }
   5716     }
   5717     if (oldE->idAtt)
   5718       newE->idAtt = (ATTRIBUTE_ID *)
   5719           lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
   5720     newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
   5721     if (oldE->prefix)
   5722       newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),
   5723                                       oldE->prefix->name, 0);
   5724     for (i = 0; i < newE->nDefaultAtts; i++) {
   5725       newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
   5726           lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
   5727       newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
   5728       if (oldE->defaultAtts[i].value) {
   5729         newE->defaultAtts[i].value
   5730             = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
   5731         if (!newE->defaultAtts[i].value)
   5732           return 0;
   5733       }
   5734       else
   5735         newE->defaultAtts[i].value = NULL;
   5736     }
   5737   }
   5738 
   5739   /* Copy the entity tables. */
   5740   if (!copyEntityTable(&(newDtd->generalEntities),
   5741                        &(newDtd->pool),
   5742                        &(oldDtd->generalEntities)))
   5743       return 0;
   5744 
   5745 #ifdef XML_DTD
   5746   if (!copyEntityTable(&(newDtd->paramEntities),
   5747                        &(newDtd->pool),
   5748                        &(oldDtd->paramEntities)))
   5749       return 0;
   5750   newDtd->paramEntityRead = oldDtd->paramEntityRead;
   5751 #endif /* XML_DTD */
   5752 
   5753   newDtd->keepProcessing = oldDtd->keepProcessing;
   5754   newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
   5755   newDtd->standalone = oldDtd->standalone;
   5756 
   5757   /* Don't want deep copying for scaffolding */
   5758   newDtd->in_eldecl = oldDtd->in_eldecl;
   5759   newDtd->scaffold = oldDtd->scaffold;
   5760   newDtd->contentStringLen = oldDtd->contentStringLen;
   5761   newDtd->scaffSize = oldDtd->scaffSize;
   5762   newDtd->scaffLevel = oldDtd->scaffLevel;
   5763   newDtd->scaffIndex = oldDtd->scaffIndex;
   5764 
   5765   return 1;
   5766 }  /* End dtdCopy */
   5767 
   5768 static int
   5769 copyEntityTable(HASH_TABLE *newTable,
   5770                 STRING_POOL *newPool,
   5771                 const HASH_TABLE *oldTable)
   5772 {
   5773   HASH_TABLE_ITER iter;
   5774   const XML_Char *cachedOldBase = NULL;
   5775   const XML_Char *cachedNewBase = NULL;
   5776 
   5777   hashTableIterInit(&iter, oldTable);
   5778 
   5779   for (;;) {
   5780     ENTITY *newE;
   5781     const XML_Char *name;
   5782     const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
   5783     if (!oldE)
   5784       break;
   5785     name = poolCopyString(newPool, oldE->name);
   5786     if (!name)
   5787       return 0;
   5788     newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));
   5789     if (!newE)
   5790       return 0;
   5791     if (oldE->systemId) {
   5792       const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
   5793       if (!tem)
   5794         return 0;
   5795       newE->systemId = tem;
   5796       if (oldE->base) {
   5797         if (oldE->base == cachedOldBase)
   5798           newE->base = cachedNewBase;
   5799         else {
   5800           cachedOldBase = oldE->base;
   5801           tem = poolCopyString(newPool, cachedOldBase);
   5802           if (!tem)
   5803             return 0;
   5804           cachedNewBase = newE->base = tem;
   5805         }
   5806       }
   5807       if (oldE->publicId) {
   5808         tem = poolCopyString(newPool, oldE->publicId);
   5809         if (!tem)
   5810           return 0;
   5811         newE->publicId = tem;
   5812       }
   5813     }
   5814     else {
   5815       const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,
   5816                                             oldE->textLen);
   5817       if (!tem)
   5818         return 0;
   5819       newE->textPtr = tem;
   5820       newE->textLen = oldE->textLen;
   5821     }
   5822     if (oldE->notation) {
   5823       const XML_Char *tem = poolCopyString(newPool, oldE->notation);
   5824       if (!tem)
   5825         return 0;
   5826       newE->notation = tem;
   5827     }
   5828     newE->is_param = oldE->is_param;
   5829     newE->is_internal = oldE->is_internal;
   5830   }
   5831   return 1;
   5832 }
   5833 
   5834 #define INIT_POWER 6
   5835 
   5836 static XML_Bool FASTCALL
   5837 keyeq(KEY s1, KEY s2)
   5838 {
   5839   for (; *s1 == *s2; s1++, s2++)
   5840     if (*s1 == 0)
   5841       return XML_TRUE;
   5842   return XML_FALSE;
   5843 }
   5844 
   5845 static unsigned long FASTCALL
   5846 hash(KEY s)
   5847 {
   5848   unsigned long h = 0;
   5849   while (*s)
   5850     h = CHAR_HASH(h, *s++);
   5851   return h;
   5852 }
   5853 
   5854 static NAMED *
   5855 lookup(HASH_TABLE *table, KEY name, size_t createSize)
   5856 {
   5857   size_t i;
   5858   if (table->size == 0) {
   5859     size_t tsize;
   5860     if (!createSize)
   5861       return NULL;
   5862     table->power = INIT_POWER;
   5863     /* table->size is a power of 2 */
   5864     table->size = (size_t)1 << INIT_POWER;
   5865     tsize = table->size * sizeof(NAMED *);
   5866     table->v = (NAMED **)table->mem->malloc_fcn(tsize);
   5867     if (!table->v) {
   5868       table->size = 0;
   5869       return NULL;
   5870     }
   5871     memset(table->v, 0, tsize);
   5872     i = hash(name) & ((unsigned long)table->size - 1);
   5873   }
   5874   else {
   5875     unsigned long h = hash(name);
   5876     unsigned long mask = (unsigned long)table->size - 1;
   5877     unsigned char step = 0;
   5878     i = h & mask;
   5879     while (table->v[i]) {
   5880       if (keyeq(name, table->v[i]->name))
   5881         return table->v[i];
   5882       if (!step)
   5883         step = PROBE_STEP(h, mask, table->power);
   5884       i < step ? (i += table->size - step) : (i -= step);
   5885     }
   5886     if (!createSize)
   5887       return NULL;
   5888 
   5889     /* check for overflow (table is half full) */
   5890     if (table->used >> (table->power - 1)) {
   5891       unsigned char newPower = table->power + 1;
   5892       size_t newSize = (size_t)1 << newPower;
   5893       unsigned long newMask = (unsigned long)newSize - 1;
   5894       size_t tsize = newSize * sizeof(NAMED *);
   5895       NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
   5896       if (!newV)
   5897         return NULL;
   5898       memset(newV, 0, tsize);
   5899       for (i = 0; i < table->size; i++)
   5900         if (table->v[i]) {
   5901           unsigned long newHash = hash(table->v[i]->name);
   5902           size_t j = newHash & newMask;
   5903           step = 0;
   5904           while (newV[j]) {
   5905             if (!step)
   5906               step = PROBE_STEP(newHash, newMask, newPower);
   5907             j < step ? (j += newSize - step) : (j -= step);
   5908           }
   5909           newV[j] = table->v[i];
   5910         }
   5911       table->mem->free_fcn(table->v);
   5912       table->v = newV;
   5913       table->power = newPower;
   5914       table->size = newSize;
   5915       i = h & newMask;
   5916       step = 0;
   5917       while (table->v[i]) {
   5918         if (!step)
   5919           step = PROBE_STEP(h, newMask, newPower);
   5920         i < step ? (i += newSize - step) : (i -= step);
   5921       }
   5922     }
   5923   }
   5924   table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
   5925   if (!table->v[i])
   5926     return NULL;
   5927   memset(table->v[i], 0, createSize);
   5928   table->v[i]->name = name;
   5929   (table->used)++;
   5930   return table->v[i];
   5931 }
   5932 
   5933 static void FASTCALL
   5934 hashTableClear(HASH_TABLE *table)
   5935 {
   5936   size_t i;
   5937   for (i = 0; i < table->size; i++) {
   5938     table->mem->free_fcn(table->v[i]);
   5939     table->v[i] = NULL;
   5940   }
   5941   table->used = 0;
   5942 }
   5943 
   5944 static void FASTCALL
   5945 hashTableDestroy(HASH_TABLE *table)
   5946 {
   5947   size_t i;
   5948   for (i = 0; i < table->size; i++)
   5949     table->mem->free_fcn(table->v[i]);
   5950   table->mem->free_fcn(table->v);
   5951 }
   5952 
   5953 static void FASTCALL
   5954 hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)
   5955 {
   5956   p->power = 0;
   5957   p->size = 0;
   5958   p->used = 0;
   5959   p->v = NULL;
   5960   p->mem = ms;
   5961 }
   5962 
   5963 static void FASTCALL
   5964 hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table)
   5965 {
   5966   iter->p = table->v;
   5967   iter->end = iter->p + table->size;
   5968 }
   5969 
   5970 static NAMED * FASTCALL
   5971 hashTableIterNext(HASH_TABLE_ITER *iter)
   5972 {
   5973   while (iter->p != iter->end) {
   5974     NAMED *tem = *(iter->p)++;
   5975     if (tem)
   5976       return tem;
   5977   }
   5978   return NULL;
   5979 }
   5980 
   5981 static void FASTCALL
   5982 poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms)
   5983 {
   5984   pool->blocks = NULL;
   5985   pool->freeBlocks = NULL;
   5986   pool->start = NULL;
   5987   pool->ptr = NULL;
   5988   pool->end = NULL;
   5989   pool->mem = ms;
   5990 }
   5991 
   5992 static void FASTCALL
   5993 poolClear(STRING_POOL *pool)
   5994 {
   5995   if (!pool->freeBlocks)
   5996     pool->freeBlocks = pool->blocks;
   5997   else {
   5998     BLOCK *p = pool->blocks;
   5999     while (p) {
   6000       BLOCK *tem = p->next;
   6001       p->next = pool->freeBlocks;
   6002       pool->freeBlocks = p;
   6003       p = tem;
   6004     }
   6005   }
   6006   pool->blocks = NULL;
   6007   pool->start = NULL;
   6008   pool->ptr = NULL;
   6009   pool->end = NULL;
   6010 }
   6011 
   6012 static void FASTCALL
   6013 poolDestroy(STRING_POOL *pool)
   6014 {
   6015   BLOCK *p = pool->blocks;
   6016   while (p) {
   6017     BLOCK *tem = p->next;
   6018     pool->mem->free_fcn(p);
   6019     p = tem;
   6020   }
   6021   p = pool->freeBlocks;
   6022   while (p) {
   6023     BLOCK *tem = p->next;
   6024     pool->mem->free_fcn(p);
   6025     p = tem;
   6026   }
   6027 }
   6028 
   6029 static XML_Char *
   6030 poolAppend(STRING_POOL *pool, const ENCODING *enc,
   6031            const char *ptr, const char *end)
   6032 {
   6033   if (!pool->ptr && !poolGrow(pool))
   6034     return NULL;
   6035   for (;;) {
   6036     XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
   6037     if (ptr == end)
   6038       break;
   6039     if (!poolGrow(pool))
   6040       return NULL;
   6041   }
   6042   return pool->start;
   6043 }
   6044 
   6045 static const XML_Char * FASTCALL
   6046 poolCopyString(STRING_POOL *pool, const XML_Char *s)
   6047 {
   6048   do {
   6049     if (!poolAppendChar(pool, *s))
   6050       return NULL;
   6051   } while (*s++);
   6052   s = pool->start;
   6053   poolFinish(pool);
   6054   return s;
   6055 }
   6056 
   6057 static const XML_Char *
   6058 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
   6059 {
   6060   if (!pool->ptr && !poolGrow(pool))
   6061     return NULL;
   6062   for (; n > 0; --n, s++) {
   6063     if (!poolAppendChar(pool, *s))
   6064       return NULL;
   6065   }
   6066   s = pool->start;
   6067   poolFinish(pool);
   6068   return s;
   6069 }
   6070 
   6071 static const XML_Char * FASTCALL
   6072 poolAppendString(STRING_POOL *pool, const XML_Char *s)
   6073 {
   6074   while (*s) {
   6075     if (!poolAppendChar(pool, *s))
   6076       return NULL;
   6077     s++;
   6078   }
   6079   return pool->start;
   6080 }
   6081 
   6082 static XML_Char *
   6083 poolStoreString(STRING_POOL *pool, const ENCODING *enc,
   6084                 const char *ptr, const char *end)
   6085 {
   6086   if (!poolAppend(pool, enc, ptr, end))
   6087     return NULL;
   6088   if (pool->ptr == pool->end && !poolGrow(pool))
   6089     return NULL;
   6090   *(pool->ptr)++ = 0;
   6091   return pool->start;
   6092 }
   6093 
   6094 static XML_Bool FASTCALL
   6095 poolGrow(STRING_POOL *pool)
   6096 {
   6097   if (pool->freeBlocks) {
   6098     if (pool->start == 0) {
   6099       pool->blocks = pool->freeBlocks;
   6100       pool->freeBlocks = pool->freeBlocks->next;
   6101       pool->blocks->next = NULL;
   6102       pool->start = pool->blocks->s;
   6103       pool->end = pool->start + pool->blocks->size;
   6104       pool->ptr = pool->start;
   6105       return XML_TRUE;
   6106     }
   6107     if (pool->end - pool->start < pool->freeBlocks->size) {
   6108       BLOCK *tem = pool->freeBlocks->next;
   6109       pool->freeBlocks->next = pool->blocks;
   6110       pool->blocks = pool->freeBlocks;
   6111       pool->freeBlocks = tem;
   6112       memcpy(pool->blocks->s, pool->start,
   6113              (pool->end - pool->start) * sizeof(XML_Char));
   6114       pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
   6115       pool->start = pool->blocks->s;
   6116       pool->end = pool->start + pool->blocks->size;
   6117       return XML_TRUE;
   6118     }
   6119   }
   6120   if (pool->blocks && pool->start == pool->blocks->s) {
   6121     int blockSize = (int)(pool->end - pool->start)*2;
   6122     pool->blocks = (BLOCK *)
   6123       pool->mem->realloc_fcn(pool->blocks,
   6124                              (offsetof(BLOCK, s)
   6125                               + blockSize * sizeof(XML_Char)));
   6126     if (pool->blocks == NULL)
   6127       return XML_FALSE;
   6128     pool->blocks->size = blockSize;
   6129     pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
   6130     pool->start = pool->blocks->s;
   6131     pool->end = pool->start + blockSize;
   6132   }
   6133   else {
   6134     BLOCK *tem;
   6135     int blockSize = (int)(pool->end - pool->start);
   6136     if (blockSize < INIT_BLOCK_SIZE)
   6137       blockSize = INIT_BLOCK_SIZE;
   6138     else
   6139       blockSize *= 2;
   6140     tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)
   6141                                         + blockSize * sizeof(XML_Char));
   6142     if (!tem)
   6143       return XML_FALSE;
   6144     tem->size = blockSize;
   6145     tem->next = pool->blocks;
   6146     pool->blocks = tem;
   6147     if (pool->ptr != pool->start)
   6148       memcpy(tem->s, pool->start,
   6149              (pool->ptr - pool->start) * sizeof(XML_Char));
   6150     pool->ptr = tem->s + (pool->ptr - pool->start);
   6151     pool->start = tem->s;
   6152     pool->end = tem->s + blockSize;
   6153   }
   6154   return XML_TRUE;
   6155 }
   6156 
   6157 static int FASTCALL
   6158 nextScaffoldPart(XML_Parser parser)
   6159 {
   6160   DTD * const dtd = _dtd;  /* save one level of indirection */
   6161   CONTENT_SCAFFOLD * me;
   6162   int next;
   6163 
   6164   if (!dtd->scaffIndex) {
   6165     dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));
   6166     if (!dtd->scaffIndex)
   6167       return -1;
   6168     dtd->scaffIndex[0] = 0;
   6169   }
   6170 
   6171   if (dtd->scaffCount >= dtd->scaffSize) {
   6172     CONTENT_SCAFFOLD *temp;
   6173     if (dtd->scaffold) {
   6174       temp = (CONTENT_SCAFFOLD *)
   6175         REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
   6176       if (temp == NULL)
   6177         return -1;
   6178       dtd->scaffSize *= 2;
   6179     }
   6180     else {
   6181       temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS
   6182                                         * sizeof(CONTENT_SCAFFOLD));
   6183       if (temp == NULL)
   6184         return -1;
   6185       dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
   6186     }
   6187     dtd->scaffold = temp;
   6188   }
   6189   next = dtd->scaffCount++;
   6190   me = &dtd->scaffold[next];
   6191   if (dtd->scaffLevel) {
   6192     CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];
   6193     if (parent->lastchild) {
   6194       dtd->scaffold[parent->lastchild].nextsib = next;
   6195     }
   6196     if (!parent->childcnt)
   6197       parent->firstchild = next;
   6198     parent->lastchild = next;
   6199     parent->childcnt++;
   6200   }
   6201   me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
   6202   return next;
   6203 }
   6204 
   6205 static void
   6206 build_node(XML_Parser parser,
   6207            int src_node,
   6208            XML_Content *dest,
   6209            XML_Content **contpos,
   6210            XML_Char **strpos)
   6211 {
   6212   DTD * const dtd = _dtd;  /* save one level of indirection */
   6213   dest->type = dtd->scaffold[src_node].type;
   6214   dest->quant = dtd->scaffold[src_node].quant;
   6215   if (dest->type == XML_CTYPE_NAME) {
   6216     const XML_Char *src;
   6217     dest->name = *strpos;
   6218     src = dtd->scaffold[src_node].name;
   6219     for (;;) {
   6220       *(*strpos)++ = *src;
   6221       if (!*src)
   6222         break;
   6223       src++;
   6224     }
   6225     dest->numchildren = 0;
   6226     dest->children = NULL;
   6227   }
   6228   else {
   6229     unsigned int i;
   6230     int cn;
   6231     dest->numchildren = dtd->scaffold[src_node].childcnt;
   6232     dest->children = *contpos;
   6233     *contpos += dest->numchildren;
   6234     for (i = 0, cn = dtd->scaffold[src_node].firstchild;
   6235          i < dest->numchildren;
   6236          i++, cn = dtd->scaffold[cn].nextsib) {
   6237       build_node(parser, cn, &(dest->children[i]), contpos, strpos);
   6238     }
   6239     dest->name = NULL;
   6240   }
   6241 }
   6242 
   6243 static XML_Content *
   6244 build_model (XML_Parser parser)
   6245 {
   6246   DTD * const dtd = _dtd;  /* save one level of indirection */
   6247   XML_Content *ret;
   6248   XML_Content *cpos;
   6249   XML_Char * str;
   6250   int allocsize = (dtd->scaffCount * sizeof(XML_Content)
   6251                    + (dtd->contentStringLen * sizeof(XML_Char)));
   6252 
   6253   ret = (XML_Content *)MALLOC(allocsize);
   6254   if (!ret)
   6255     return NULL;
   6256 
   6257   str =  (XML_Char *) (&ret[dtd->scaffCount]);
   6258   cpos = &ret[1];
   6259 
   6260   build_node(parser, 0, ret, &cpos, &str);
   6261   return ret;
   6262 }
   6263 
   6264 static ELEMENT_TYPE *
   6265 getElementType(XML_Parser parser,
   6266                const ENCODING *enc,
   6267                const char *ptr,
   6268                const char *end)
   6269 {
   6270   DTD * const dtd = _dtd;  /* save one level of indirection */
   6271   const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
   6272   ELEMENT_TYPE *ret;
   6273 
   6274   if (!name)
   6275     return NULL;
   6276   ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
   6277   if (!ret)
   6278     return NULL;
   6279   if (ret->name != name)
   6280     poolDiscard(&dtd->pool);
   6281   else {
   6282     poolFinish(&dtd->pool);
   6283     if (!setElementTypePrefix(parser, ret))
   6284       return NULL;
   6285   }
   6286   return ret;
   6287 }
   6288