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

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