Modules/expat/xmlparse.c

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