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