AppPkg/Applications/Python/Python-2.7.2/Modules/expat/xmlparse.c

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