src/protocols/jabber/xmlparse.c

   1 /*
   2 The contents of this file are subject to the Mozilla Public License
   3 Version 1.1 (the "License"); you may not use this file except in
   4 compliance with the License. You may obtain a copy of the License at
   5 http://www.mozilla.org/MPL/
   6
   7 Software distributed under the License is distributed on an "AS IS"
   8 basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
   9 License for the specific language governing rights and limitations
  10 under the License.
  11
  12 The Original Code is expat.
  13
  14 The Initial Developer of the Original Code is James Clark.
  15 Portions created by James Clark are Copyright (C) 1998, 1999
  16 James Clark. All Rights Reserved.
  17
  18 Contributor(s):
  19
  20 Alternatively, the contents of this file may be used under the terms
  21 of the GNU General Public License (the "GPL"), in which case the
  22 provisions of the GPL are applicable instead of those above.  If you
  23 wish to allow use of your version of this file only under the terms of
  24 the GPL and not to allow others to use your version of this file under
  25 the MPL, indicate your decision by deleting the provisions above and
  26 replace them with the notice and other provisions required by the
  27 GPL. If you do not delete the provisions above, a recipient may use
  28 your version of this file under either the MPL or the GPL.
  29 */
  30
  31 #include "xmldef.h"
  32 #include "xmlparse.h"
  33
  34 #ifdef XML_UNICODE
  35 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
  36 #define XmlConvert XmlUtf16Convert
  37 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
  38 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
  39 #define XmlEncode XmlUtf16Encode
  40 #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
  41 typedef unsigned short ICHAR;
  42 #else
  43 #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
  44 #define XmlConvert XmlUtf8Convert
  45 #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
  46 #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
  47 #define XmlEncode XmlUtf8Encode
  48 #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
  49 typedef char ICHAR;
  50 #endif
  51
  52
  53 #ifndef XML_NS
  54
  55 #define XmlInitEncodingNS XmlInitEncoding
  56 #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
  57 #undef XmlGetInternalEncodingNS
  58 #define XmlGetInternalEncodingNS XmlGetInternalEncoding
  59 #define XmlParseXmlDeclNS XmlParseXmlDecl
  60
  61 #endif
  62
  63
  64 #ifdef XML_UNICODE_WCHAR_T
  65 #define XML_T(x) L ## x
  66 #else
  67 #define XML_T(x) x
  68 #endif
  69
  70 /* Round up n to be a multiple of sz, where sz is a power of 2. */
  71 #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))
  72
  73 #include "xmltok.h"
  74 #include "xmlrole.h"
  75 #include "hashtable.h"
  76
  77 #define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */
  78 #define INIT_DATA_BUF_SIZE 1024
  79 #define INIT_ATTS_SIZE 16
  80 #define INIT_BLOCK_SIZE 1024
  81 #define INIT_BUFFER_SIZE 1024
  82
  83 #define EXPAND_SPARE 24
  84
  85 typedef struct binding {
  86     struct prefix *prefix;
  87     struct binding *nextTagBinding;
  88     struct binding *prevPrefixBinding;
  89     const struct attribute_id *attId;
  90     XML_Char *uri;
  91     int uriLen;
  92     int uriAlloc;
  93 } BINDING;
  94
  95 typedef struct prefix {
  96     const XML_Char *name;
  97     BINDING *binding;
  98 } PREFIX;
  99
 100 typedef struct {
 101     const XML_Char *str;
 102     const XML_Char *localPart;
 103     int uriLen;
 104 } TAG_NAME;
 105
 106 typedef struct tag {
 107     struct tag *parent;
 108     const char *rawName;
 109     int rawNameLength;
 110     TAG_NAME name;
 111     char *buf;
 112     char *bufEnd;
 113     BINDING *bindings;
 114 } TAG;
 115
 116 typedef struct {
 117     const XML_Char *name;
 118     const XML_Char *textPtr;
 119     int textLen;
 120     const XML_Char *systemId;
 121     const XML_Char *base;
 122     const XML_Char *publicId;
 123     const XML_Char *notation;
 124     char open;
 125 } ENTITY;
 126
 127 typedef struct block {
 128     struct block *next;
 129     int size;
 130     XML_Char s[1];
 131 } BLOCK;
 132
 133 typedef struct {
 134     BLOCK *blocks;
 135     BLOCK *freeBlocks;
 136     const XML_Char *end;
 137     XML_Char *ptr;
 138     XML_Char *start;
 139 } STRING_POOL;
 140
 141 /* The XML_Char before the name is used to determine whether
 142 an attribute has been specified. */
 143 typedef struct attribute_id {
 144     XML_Char *name;
 145     PREFIX *prefix;
 146     char maybeTokenized;
 147     char xmlns;
 148 } ATTRIBUTE_ID;
 149
 150 typedef struct {
 151     const ATTRIBUTE_ID *id;
 152     char isCdata;
 153     const XML_Char *value;
 154 } DEFAULT_ATTRIBUTE;
 155
 156 typedef struct {
 157     const XML_Char *name;
 158     PREFIX *prefix;
 159     int nDefaultAtts;
 160     int allocDefaultAtts;
 161     DEFAULT_ATTRIBUTE *defaultAtts;
 162 } ELEMENT_TYPE;
 163
 164 typedef struct {
 165     HASH_TABLE generalEntities;
 166     HASH_TABLE elementTypes;
 167     HASH_TABLE attributeIds;
 168     HASH_TABLE prefixes;
 169     STRING_POOL pool;
 170     int complete;
 171     int standalone;
 172     const XML_Char *base;
 173     PREFIX defaultPrefix;
 174 } DTD;
 175
 176 typedef struct open_internal_entity {
 177     const char *internalEventPtr;
 178     const char *internalEventEndPtr;
 179     struct open_internal_entity *next;
 180     ENTITY *entity;
 181 } OPEN_INTERNAL_ENTITY;
 182
 183 typedef enum XML_Error Processor(XML_Parser parser,
 184                                  const char *start,
 185                                  const char *end,
 186                                  const char **endPtr);
 187
 188 static Processor prologProcessor;
 189 static Processor prologInitProcessor;
 190 static Processor contentProcessor;
 191 static Processor cdataSectionProcessor;
 192 static Processor epilogProcessor;
 193 static Processor errorProcessor;
 194 static Processor externalEntityInitProcessor;
 195 static Processor externalEntityInitProcessor2;
 196 static Processor externalEntityInitProcessor3;
 197 static Processor externalEntityContentProcessor;
 198
 199 static enum XML_Error
 200 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);
 201 static enum XML_Error
 202 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);
 203 static enum XML_Error
 204 initializeEncoding(XML_Parser parser);
 205 static enum XML_Error
 206 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
 207           const char *start, const char *end, const char **endPtr);
 208 static enum XML_Error
 209 doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
 210 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *, const char *s,
 211                                 TAG_NAME *tagNamePtr, BINDING **bindingsPtr);
 212 static
 213 int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr);
 214 static int
 215 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, int isCdata, const XML_Char *dfltValue);
 216 static enum XML_Error
 217 storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
 218                     STRING_POOL *);
 219 static enum XML_Error
 220 appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
 221                      STRING_POOL *);
 222 static ATTRIBUTE_ID *
 223 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
 224 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
 225 static enum XML_Error
 226 storeEntityValue(XML_Parser parser, const char *start, const char *end);
 227 static int
 228 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
 229 static int
 230 reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
 231 static void
 232 reportDefault(XML_Parser parser, const ENCODING *enc, const char *start, const char *end);
 233
 234 static const XML_Char *getContext(XML_Parser parser);
 235 static int setContext(XML_Parser parser, const XML_Char *context);
 236 static void normalizePublicId(XML_Char *s);
 237 static int dtdInit(DTD *);
 238 static void dtdDestroy(DTD *);
 239 static int dtdCopy(DTD *newDtd, const DTD *oldDtd);
 240 static void poolInit(STRING_POOL *);
 241 static void poolClear(STRING_POOL *);
 242 static void poolDestroy(STRING_POOL *);
 243 static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
 244                             const char *ptr, const char *end);
 245 static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
 246                                  const char *ptr, const char *end);
 247 static int poolGrow(STRING_POOL *pool);
 248 static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s);
 249 static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);
 250
 251 #define poolStart(pool) ((pool)->start)
 252 #define poolEnd(pool) ((pool)->ptr)
 253 #define poolLength(pool) ((pool)->ptr - (pool)->start)
 254 #define poolChop(pool) ((void)--(pool->ptr))
 255 #define poolLastChar(pool) (((pool)->ptr)[-1])
 256 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)
 257 #define poolFinish(pool) ((pool)->start = (pool)->ptr)
 258 #define poolAppendChar(pool, c) \
 259   (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
 260    ? 0 \
 261    : ((*((pool)->ptr)++ = c), 1))
 262
 263 typedef struct {
 264     /* The first member must be userData so that the XML_GetUserData macro works. */
 265     void *m_userData;
 266     void *m_handlerArg;
 267     char *m_buffer;
 268     /* first character to be parsed */
 269     const char *m_bufferPtr;
 270     /* past last character to be parsed */
 271     char *m_bufferEnd;
 272     /* allocated end of buffer */
 273     const char *m_bufferLim;
 274     long m_parseEndByteIndex;
 275     const char *m_parseEndPtr;
 276     XML_Char *m_dataBuf;
 277     XML_Char *m_dataBufEnd;
 278     XML_StartElementHandler m_startElementHandler;
 279     XML_EndElementHandler m_endElementHandler;
 280     XML_CharacterDataHandler m_characterDataHandler;
 281     XML_ProcessingInstructionHandler m_processingInstructionHandler;
 282     XML_CommentHandler m_commentHandler;
 283     XML_StartCdataSectionHandler m_startCdataSectionHandler;
 284     XML_EndCdataSectionHandler m_endCdataSectionHandler;
 285     XML_DefaultHandler m_defaultHandler;
 286     XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
 287     XML_NotationDeclHandler m_notationDeclHandler;
 288     XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
 289     XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
 290     XML_NotStandaloneHandler m_notStandaloneHandler;
 291     XML_ExternalEntityRefHandler m_externalEntityRefHandler;
 292     void *m_externalEntityRefHandlerArg;
 293     XML_UnknownEncodingHandler m_unknownEncodingHandler;
 294     const ENCODING *m_encoding;
 295     INIT_ENCODING m_initEncoding;
 296     const XML_Char *m_protocolEncodingName;
 297     int m_ns;
 298     void *m_unknownEncodingMem;
 299     void *m_unknownEncodingData;
 300     void *m_unknownEncodingHandlerData;
 301     void (*m_unknownEncodingRelease)(void *);
 302     PROLOG_STATE m_prologState;
 303     Processor *m_processor;
 304     enum XML_Error m_errorCode;
 305     const char *m_eventPtr;
 306     const char *m_eventEndPtr;
 307     const char *m_positionPtr;
 308     OPEN_INTERNAL_ENTITY *m_openInternalEntities;
 309     int m_defaultExpandInternalEntities;
 310     int m_tagLevel;
 311     ENTITY *m_declEntity;
 312     const XML_Char *m_declNotationName;
 313     const XML_Char *m_declNotationPublicId;
 314     ELEMENT_TYPE *m_declElementType;
 315     ATTRIBUTE_ID *m_declAttributeId;
 316     char m_declAttributeIsCdata;
 317     DTD m_dtd;
 318     TAG *m_tagStack;
 319     TAG *m_freeTagList;
 320     BINDING *m_inheritedBindings;
 321     BINDING *m_freeBindingList;
 322     int m_attsSize;
 323     int m_nSpecifiedAtts;
 324     ATTRIBUTE *m_atts;
 325     POSITION m_position;
 326     STRING_POOL m_tempPool;
 327     STRING_POOL m_temp2Pool;
 328     char *m_groupConnector;
 329     unsigned m_groupSize;
 330     int m_hadExternalDoctype;
 331     XML_Char m_namespaceSeparator;
 332 } Parser;
 333
 334 #define userData (((Parser *)parser)->m_userData)
 335 #define handlerArg (((Parser *)parser)->m_handlerArg)
 336 #define startElementHandler (((Parser *)parser)->m_startElementHandler)
 337 #define endElementHandler (((Parser *)parser)->m_endElementHandler)
 338 #define characterDataHandler (((Parser *)parser)->m_characterDataHandler)
 339 #define processingInstructionHandler (((Parser *)parser)->m_processingInstructionHandler)
 340 #define commentHandler (((Parser *)parser)->m_commentHandler)
 341 #define startCdataSectionHandler (((Parser *)parser)->m_startCdataSectionHandler)
 342 #define endCdataSectionHandler (((Parser *)parser)->m_endCdataSectionHandler)
 343 #define defaultHandler (((Parser *)parser)->m_defaultHandler)
 344 #define unparsedEntityDeclHandler (((Parser *)parser)->m_unparsedEntityDeclHandler)
 345 #define notationDeclHandler (((Parser *)parser)->m_notationDeclHandler)
 346 #define startNamespaceDeclHandler (((Parser *)parser)->m_startNamespaceDeclHandler)
 347 #define endNamespaceDeclHandler (((Parser *)parser)->m_endNamespaceDeclHandler)
 348 #define notStandaloneHandler (((Parser *)parser)->m_notStandaloneHandler)
 349 #define externalEntityRefHandler (((Parser *)parser)->m_externalEntityRefHandler)
 350 #define externalEntityRefHandlerArg (((Parser *)parser)->m_externalEntityRefHandlerArg)
 351 #define unknownEncodingHandler (((Parser *)parser)->m_unknownEncodingHandler)
 352 #define encoding (((Parser *)parser)->m_encoding)
 353 #define initEncoding (((Parser *)parser)->m_initEncoding)
 354 #define unknownEncodingMem (((Parser *)parser)->m_unknownEncodingMem)
 355 #define unknownEncodingData (((Parser *)parser)->m_unknownEncodingData)
 356 #define unknownEncodingHandlerData \
 357   (((Parser *)parser)->m_unknownEncodingHandlerData)
 358 #define unknownEncodingRelease (((Parser *)parser)->m_unknownEncodingRelease)
 359 #define protocolEncodingName (((Parser *)parser)->m_protocolEncodingName)
 360 #define ns (((Parser *)parser)->m_ns)
 361 #define prologState (((Parser *)parser)->m_prologState)
 362 #define processor (((Parser *)parser)->m_processor)
 363 #define errorCode (((Parser *)parser)->m_errorCode)
 364 #define eventPtr (((Parser *)parser)->m_eventPtr)
 365 #define eventEndPtr (((Parser *)parser)->m_eventEndPtr)
 366 #define positionPtr (((Parser *)parser)->m_positionPtr)
 367 #define position (((Parser *)parser)->m_position)
 368 #define openInternalEntities (((Parser *)parser)->m_openInternalEntities)
 369 #define defaultExpandInternalEntities (((Parser *)parser)->m_defaultExpandInternalEntities)
 370 #define tagLevel (((Parser *)parser)->m_tagLevel)
 371 #define buffer (((Parser *)parser)->m_buffer)
 372 #define bufferPtr (((Parser *)parser)->m_bufferPtr)
 373 #define bufferEnd (((Parser *)parser)->m_bufferEnd)
 374 #define parseEndByteIndex (((Parser *)parser)->m_parseEndByteIndex)
 375 #define parseEndPtr (((Parser *)parser)->m_parseEndPtr)
 376 #define bufferLim (((Parser *)parser)->m_bufferLim)
 377 #define dataBuf (((Parser *)parser)->m_dataBuf)
 378 #define dataBufEnd (((Parser *)parser)->m_dataBufEnd)
 379 #define dtd (((Parser *)parser)->m_dtd)
 380 #define declEntity (((Parser *)parser)->m_declEntity)
 381 #define declNotationName (((Parser *)parser)->m_declNotationName)
 382 #define declNotationPublicId (((Parser *)parser)->m_declNotationPublicId)
 383 #define declElementType (((Parser *)parser)->m_declElementType)
 384 #define declAttributeId (((Parser *)parser)->m_declAttributeId)
 385 #define declAttributeIsCdata (((Parser *)parser)->m_declAttributeIsCdata)
 386 #define freeTagList (((Parser *)parser)->m_freeTagList)
 387 #define freeBindingList (((Parser *)parser)->m_freeBindingList)
 388 #define inheritedBindings (((Parser *)parser)->m_inheritedBindings)
 389 #define tagStack (((Parser *)parser)->m_tagStack)
 390 #define atts (((Parser *)parser)->m_atts)
 391 #define attsSize (((Parser *)parser)->m_attsSize)
 392 #define nSpecifiedAtts (((Parser *)parser)->m_nSpecifiedAtts)
 393 #define tempPool (((Parser *)parser)->m_tempPool)
 394 #define temp2Pool (((Parser *)parser)->m_temp2Pool)
 395 #define groupConnector (((Parser *)parser)->m_groupConnector)
 396 #define groupSize (((Parser *)parser)->m_groupSize)
 397 #define hadExternalDoctype (((Parser *)parser)->m_hadExternalDoctype)
 398 #define namespaceSeparator (((Parser *)parser)->m_namespaceSeparator)
 399
 400 #ifdef _MSC_VER
 401 #ifdef _DEBUG
 402 Parser *asParser(XML_Parser parser)
 403 {
 404     return parser;
 405 }
 406 #endif
 407 #endif
 408
 409 XML_Parser XML_ParserCreate(const XML_Char *encodingName)
 410 {
 411     XML_Parser parser = malloc(sizeof(Parser));
 412     if (!parser)
 413         return parser;
 414     processor = prologInitProcessor;
 415     XmlPrologStateInit(&prologState);
 416     userData = 0;
 417     handlerArg = 0;
 418     startElementHandler = 0;
 419     endElementHandler = 0;
 420     characterDataHandler = 0;
 421     processingInstructionHandler = 0;
 422     commentHandler = 0;
 423     startCdataSectionHandler = 0;
 424     endCdataSectionHandler = 0;
 425     defaultHandler = 0;
 426     unparsedEntityDeclHandler = 0;
 427     notationDeclHandler = 0;
 428     startNamespaceDeclHandler = 0;
 429     endNamespaceDeclHandler = 0;
 430     notStandaloneHandler = 0;
 431     externalEntityRefHandler = 0;
 432     externalEntityRefHandlerArg = parser;
 433     unknownEncodingHandler = 0;
 434     buffer = 0;
 435     bufferPtr = 0;
 436     bufferEnd = 0;
 437     parseEndByteIndex = 0;
 438     parseEndPtr = 0;
 439     bufferLim = 0;
 440     declElementType = 0;
 441     declAttributeId = 0;
 442     declEntity = 0;
 443     declNotationName = 0;
 444     declNotationPublicId = 0;
 445     memset(&position, 0, sizeof(POSITION));
 446     errorCode = XML_ERROR_NONE;
 447     eventPtr = 0;
 448     eventEndPtr = 0;
 449     positionPtr = 0;
 450     openInternalEntities = 0;
 451     tagLevel = 0;
 452     tagStack = 0;
 453     freeTagList = 0;
 454     freeBindingList = 0;
 455     inheritedBindings = 0;
 456     attsSize = INIT_ATTS_SIZE;
 457     atts = malloc(attsSize * sizeof(ATTRIBUTE));
 458     nSpecifiedAtts = 0;
 459     dataBuf = malloc(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
 460     groupSize = 0;
 461     groupConnector = 0;
 462     hadExternalDoctype = 0;
 463     unknownEncodingMem = 0;
 464     unknownEncodingRelease = 0;
 465     unknownEncodingData = 0;
 466     unknownEncodingHandlerData = 0;
 467     namespaceSeparator = '!';
 468     ns = 0;
 469     poolInit(&tempPool);
 470     poolInit(&temp2Pool);
 471     protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
 472     if (!dtdInit(&dtd) || !atts || !dataBuf
 473             || (encodingName && !protocolEncodingName)) {
 474         XML_ParserFree(parser);
 475         return 0;
 476     }
 477     dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;
 478     XmlInitEncoding(&initEncoding, &encoding, 0);
 479     return parser;
 480 }
 481
 482 XML_Parser XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)
 483 {
 484     static
 485     const XML_Char implicitContext[] = {
 486         XML_T('x'), XML_T('m'), XML_T('l'), XML_T('='),
 487         XML_T('h'), XML_T('t'), XML_T('t'), XML_T('p'), XML_T(':'),
 488         XML_T('/'), XML_T('/'), XML_T('w'), XML_T('w'), XML_T('w'),
 489         XML_T('.'), XML_T('w'), XML_T('3'),
 490         XML_T('.'), XML_T('o'), XML_T('r'), XML_T('g'),
 491         XML_T('/'), XML_T('X'), XML_T('M'), XML_T('L'),
 492         XML_T('/'), XML_T('1'), XML_T('9'), XML_T('9'), XML_T('8'),
 493         XML_T('/'), XML_T('n'), XML_T('a'), XML_T('m'), XML_T('e'),
 494         XML_T('s'), XML_T('p'), XML_T('a'), XML_T('c'), XML_T('e'),
 495         XML_T('\0')
 496     };
 497
 498     XML_Parser parser = XML_ParserCreate(encodingName);
 499     if (parser) {
 500         XmlInitEncodingNS(&initEncoding, &encoding, 0);
 501         ns = 1;
 502         namespaceSeparator = nsSep;
 503     }
 504     if (!setContext(parser, implicitContext)) {
 505         XML_ParserFree(parser);
 506         return 0;
 507     }
 508     return parser;
 509 }
 510
 511 int XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
 512 {
 513     if (!encodingName)
 514         protocolEncodingName = 0;
 515     else {
 516         protocolEncodingName = poolCopyString(&tempPool, encodingName);
 517         if (!protocolEncodingName)
 518             return 0;
 519     }
 520     return 1;
 521 }
 522
 523 XML_Parser XML_ExternalEntityParserCreate(XML_Parser oldParser,
 524         const XML_Char *context,
 525         const XML_Char *encodingName)
 526 {
 527     XML_Parser parser = oldParser;
 528     DTD *oldDtd = &dtd;
 529     XML_StartElementHandler oldStartElementHandler = startElementHandler;
 530     XML_EndElementHandler oldEndElementHandler = endElementHandler;
 531     XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;
 532     XML_ProcessingInstructionHandler oldProcessingInstructionHandler = processingInstructionHandler;
 533     XML_CommentHandler oldCommentHandler = commentHandler;
 534     XML_StartCdataSectionHandler oldStartCdataSectionHandler = startCdataSectionHandler;
 535     XML_EndCdataSectionHandler oldEndCdataSectionHandler = endCdataSectionHandler;
 536     XML_DefaultHandler oldDefaultHandler = defaultHandler;
 537     XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler = startNamespaceDeclHandler;
 538     XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler = endNamespaceDeclHandler;
 539     XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;
 540     XML_ExternalEntityRefHandler oldExternalEntityRefHandler = externalEntityRefHandler;
 541     XML_UnknownEncodingHandler oldUnknownEncodingHandler = unknownEncodingHandler;
 542     void *oldUserData = userData;
 543     void *oldHandlerArg = handlerArg;
 544     int oldDefaultExpandInternalEntities = defaultExpandInternalEntities;
 545     void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;
 546
 547     parser = (ns
 548               ? XML_ParserCreateNS(encodingName, namespaceSeparator)
 549               : XML_ParserCreate(encodingName));
 550     if (!parser)
 551         return 0;
 552     startElementHandler = oldStartElementHandler;
 553     endElementHandler = oldEndElementHandler;
 554     characterDataHandler = oldCharacterDataHandler;
 555     processingInstructionHandler = oldProcessingInstructionHandler;
 556     commentHandler = oldCommentHandler;
 557     startCdataSectionHandler = oldStartCdataSectionHandler;
 558     endCdataSectionHandler = oldEndCdataSectionHandler;
 559     defaultHandler = oldDefaultHandler;
 560     startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
 561     endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
 562     notStandaloneHandler = oldNotStandaloneHandler;
 563     externalEntityRefHandler = oldExternalEntityRefHandler;
 564     unknownEncodingHandler = oldUnknownEncodingHandler;
 565     userData = oldUserData;
 566     if (oldUserData == oldHandlerArg)
 567         handlerArg = userData;
 568     else
 569         handlerArg = parser;
 570     if (oldExternalEntityRefHandlerArg != oldParser)
 571         externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
 572     defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
 573     if (!dtdCopy(&dtd, oldDtd) || !setContext(parser, context)) {
 574         XML_ParserFree(parser);
 575         return 0;
 576     }
 577     processor = externalEntityInitProcessor;
 578     return parser;
 579 }
 580
 581 static
 582 void destroyBindings(BINDING *bindings)
 583 {
 584     for (;;) {
 585         BINDING *b = bindings;
 586         if (!b)
 587             break;
 588         bindings = b->nextTagBinding;
 589         free(b->uri);
 590         free(b);
 591     }
 592 }
 593
 594 void XML_ParserFree(XML_Parser parser)
 595 {
 596     for (;;) {
 597         TAG *p;
 598         if (tagStack == 0) {
 599             if (freeTagList == 0)
 600                 break;
 601             tagStack = freeTagList;
 602             freeTagList = 0;
 603         }
 604         p = tagStack;
 605         tagStack = tagStack->parent;
 606         free(p->buf);
 607         destroyBindings(p->bindings);
 608         free(p);
 609     }
 610     destroyBindings(freeBindingList);
 611     destroyBindings(inheritedBindings);
 612     poolDestroy(&tempPool);
 613     poolDestroy(&temp2Pool);
 614     dtdDestroy(&dtd);
 615     free((void *)atts);
 616     free(groupConnector);
 617     free(buffer);
 618     free(dataBuf);
 619     free(unknownEncodingMem);
 620     if (unknownEncodingRelease)
 621         unknownEncodingRelease(unknownEncodingData);
 622     free(parser);
 623 }
 624
 625 void XML_UseParserAsHandlerArg(XML_Parser parser)
 626 {
 627     handlerArg = parser;
 628 }
 629
 630 void XML_SetUserData(XML_Parser parser, void *p)
 631 {
 632     if (handlerArg == userData)
 633         handlerArg = userData = p;
 634     else
 635         userData = p;
 636 }
 637
 638 int XML_SetBase(XML_Parser parser, const XML_Char *p)
 639 {
 640     if (p) {
 641         p = poolCopyString(&dtd.pool, p);
 642         if (!p)
 643             return 0;
 644         dtd.base = p;
 645     }
 646     else
 647         dtd.base = 0;
 648     return 1;
 649 }
 650
 651 const XML_Char *XML_GetBase(XML_Parser parser)
 652 {
 653     return dtd.base;
 654 }
 655
 656 int XML_GetSpecifiedAttributeCount(XML_Parser parser)
 657 {
 658     return nSpecifiedAtts;
 659 }
 660
 661 void XML_SetElementHandler(XML_Parser parser,
 662                            XML_StartElementHandler start,
 663                            XML_EndElementHandler end)
 664 {
 665     startElementHandler = start;
 666     endElementHandler = end;
 667 }
 668
 669 void XML_SetCharacterDataHandler(XML_Parser parser,
 670                                  XML_CharacterDataHandler handler)
 671 {
 672     characterDataHandler = handler;
 673 }
 674
 675 void XML_SetProcessingInstructionHandler(XML_Parser parser,
 676         XML_ProcessingInstructionHandler handler)
 677 {
 678     processingInstructionHandler = handler;
 679 }
 680
 681 void XML_SetCommentHandler(XML_Parser parser,
 682                            XML_CommentHandler handler)
 683 {
 684     commentHandler = handler;
 685 }
 686
 687 void XML_SetCdataSectionHandler(XML_Parser parser,
 688                                 XML_StartCdataSectionHandler start,
 689                                 XML_EndCdataSectionHandler end)
 690 {
 691     startCdataSectionHandler = start;
 692     endCdataSectionHandler = end;
 693 }
 694
 695 void XML_SetDefaultHandler(XML_Parser parser,
 696                            XML_DefaultHandler handler)
 697 {
 698     defaultHandler = handler;
 699     defaultExpandInternalEntities = 0;
 700 }
 701
 702 void XML_SetDefaultHandlerExpand(XML_Parser parser,
 703                                  XML_DefaultHandler handler)
 704 {
 705     defaultHandler = handler;
 706     defaultExpandInternalEntities = 1;
 707 }
 708
 709 void XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
 710                                       XML_UnparsedEntityDeclHandler handler)
 711 {
 712     unparsedEntityDeclHandler = handler;
 713 }
 714
 715 void XML_SetNotationDeclHandler(XML_Parser parser,
 716                                 XML_NotationDeclHandler handler)
 717 {
 718     notationDeclHandler = handler;
 719 }
 720
 721 void XML_SetNamespaceDeclHandler(XML_Parser parser,
 722                                  XML_StartNamespaceDeclHandler start,
 723                                  XML_EndNamespaceDeclHandler end)
 724 {
 725     startNamespaceDeclHandler = start;
 726     endNamespaceDeclHandler = end;
 727 }
 728
 729 void XML_SetNotStandaloneHandler(XML_Parser parser,
 730                                  XML_NotStandaloneHandler handler)
 731 {
 732     notStandaloneHandler = handler;
 733 }
 734
 735 void XML_SetExternalEntityRefHandler(XML_Parser parser,
 736                                      XML_ExternalEntityRefHandler handler)
 737 {
 738     externalEntityRefHandler = handler;
 739 }
 740
 741 void XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)
 742 {
 743     if (arg)
 744         externalEntityRefHandlerArg = arg;
 745     else
 746         externalEntityRefHandlerArg = parser;
 747 }
 748
 749 void XML_SetUnknownEncodingHandler(XML_Parser parser,
 750                                    XML_UnknownEncodingHandler handler,
 751                                    void *data)
 752 {
 753     unknownEncodingHandler = handler;
 754     unknownEncodingHandlerData = data;
 755 }
 756
 757 int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
 758 {
 759     if (len == 0) {
 760         if (!isFinal)
 761             return 1;
 762         positionPtr = bufferPtr;
 763         errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
 764         if (errorCode == XML_ERROR_NONE)
 765             return 1;
 766         eventEndPtr = eventPtr;
 767         return 0;
 768     }
 769     else if (bufferPtr == bufferEnd) {
 770         const char *end;
 771         int nLeftOver;
 772         parseEndByteIndex += len;
 773         positionPtr = s;
 774         if (isFinal) {
 775             errorCode = processor(parser, s, parseEndPtr = s + len, 0);
 776             if (errorCode == XML_ERROR_NONE)
 777                 return 1;
 778             eventEndPtr = eventPtr;
 779             return 0;
 780         }
 781         errorCode = processor(parser, s, parseEndPtr = s + len, &end);
 782         if (errorCode != XML_ERROR_NONE) {
 783             eventEndPtr = eventPtr;
 784             return 0;
 785         }
 786         XmlUpdatePosition(encoding, positionPtr, end, &position);
 787         nLeftOver = s + len - end;
 788         if (nLeftOver) {
 789             if (buffer == 0 || nLeftOver > bufferLim - buffer) {
 790                 /* FIXME avoid integer overflow */
 791                 buffer = buffer == 0 ? malloc(len * 2) : realloc(buffer, len * 2);
 792                 if (!buffer) {
 793                     errorCode = XML_ERROR_NO_MEMORY;
 794                     eventPtr = eventEndPtr = 0;
 795                     return 0;
 796                 }
 797                 bufferLim = buffer + len * 2;
 798             }
 799             memcpy(buffer, end, nLeftOver);
 800             bufferPtr = buffer;
 801             bufferEnd = buffer + nLeftOver;
 802         }
 803         return 1;
 804     }
 805     else {
 806         memcpy(XML_GetBuffer(parser, len), s, len);
 807         return XML_ParseBuffer(parser, len, isFinal);
 808     }
 809 }
 810
 811 int XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
 812 {
 813     const char *start = bufferPtr;
 814     positionPtr = start;
 815     bufferEnd += len;
 816     parseEndByteIndex += len;
 817     errorCode = processor(parser, start, parseEndPtr = bufferEnd,
 818                           isFinal ? (const char **)0 : &bufferPtr);
 819     if (errorCode == XML_ERROR_NONE) {
 820         if (!isFinal)
 821             XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
 822         return 1;
 823     }
 824     else {
 825         eventEndPtr = eventPtr;
 826         return 0;
 827     }
 828 }
 829
 830 void *XML_GetBuffer(XML_Parser parser, int len)
 831 {
 832     if (len > bufferLim - bufferEnd) {
 833         /* FIXME avoid integer overflow */
 834         int neededSize = len + (bufferEnd - bufferPtr);
 835         if (neededSize  <= bufferLim - buffer) {
 836             memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
 837             bufferEnd = buffer + (bufferEnd - bufferPtr);
 838             bufferPtr = buffer;
 839         }
 840         else {
 841             char *newBuf;
 842             int bufferSize = bufferLim - bufferPtr;
 843             if (bufferSize == 0)
 844                 bufferSize = INIT_BUFFER_SIZE;
 845             do {
 846                 bufferSize *= 2;
 847             } while (bufferSize < neededSize);
 848             newBuf = malloc(bufferSize);
 849             if (newBuf == 0) {
 850                 errorCode = XML_ERROR_NO_MEMORY;
 851                 return 0;
 852             }
 853             bufferLim = newBuf + bufferSize;
 854             if (bufferPtr) {
 855                 memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
 856                 free(buffer);
 857             }
 858             bufferEnd = newBuf + (bufferEnd - bufferPtr);
 859             bufferPtr = buffer = newBuf;
 860         }
 861     }
 862     return bufferEnd;
 863 }
 864
 865 enum XML_Error XML_GetErrorCode(XML_Parser parser)
 866 {
 867     return errorCode;
 868 }
 869
 870 long XML_GetCurrentByteIndex(XML_Parser parser)
 871 {
 872     if (eventPtr)
 873         return parseEndByteIndex - (parseEndPtr - eventPtr);
 874     return -1;
 875 }
 876
 877 int XML_GetCurrentByteCount(XML_Parser parser)
 878 {
 879     if (eventEndPtr && eventPtr)
 880         return eventEndPtr - eventPtr;
 881     return 0;
 882 }
 883
 884 int XML_GetCurrentLineNumber(XML_Parser parser)
 885 {
 886     if (eventPtr) {
 887         XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
 888         positionPtr = eventPtr;
 889     }
 890     return position.lineNumber + 1;
 891 }
 892
 893 int XML_GetCurrentColumnNumber(XML_Parser parser)
 894 {
 895     if (eventPtr) {
 896         XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
 897         positionPtr = eventPtr;
 898     }
 899     return position.columnNumber;
 900 }
 901
 902 void XML_DefaultCurrent(XML_Parser parser)
 903 {
 904     if (defaultHandler) {
 905         if (openInternalEntities)
 906             reportDefault(parser,
 907                           ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding(),
 908                           openInternalEntities->internalEventPtr,
 909                           openInternalEntities->internalEventEndPtr);
 910         else
 911             reportDefault(parser, encoding, eventPtr, eventEndPtr);
 912     }
 913 }
 914
 915 const XML_LChar *XML_ErrorString(int code)
 916 {
 917     static const XML_LChar *message[] = {
 918         0,
 919         XML_T("out of memory"),
 920         XML_T("syntax error"),
 921         XML_T("no element found"),
 922         XML_T("not well-formed"),
 923         XML_T("unclosed token"),
 924         XML_T("unclosed token"),
 925         XML_T("mismatched tag"),
 926         XML_T("duplicate attribute"),
 927         XML_T("junk after document element"),
 928         XML_T("illegal parameter entity reference"),
 929         XML_T("undefined entity"),
 930         XML_T("recursive entity reference"),
 931         XML_T("asynchronous entity"),
 932         XML_T("reference to invalid character number"),
 933         XML_T("reference to binary entity"),
 934         XML_T("reference to external entity in attribute"),
 935         XML_T("xml processing instruction not at start of external entity"),
 936         XML_T("unknown encoding"),
 937         XML_T("encoding specified in XML declaration is incorrect"),
 938         XML_T("unclosed CDATA section"),
 939         XML_T("error in processing external entity reference"),
 940         XML_T("document is not standalone")
 941     };
 942     if (code > 0 && code < sizeof(message)/sizeof(message[0]))
 943         return message[code];
 944     return 0;
 945 }
 946
 947 static
 948 enum XML_Error contentProcessor(XML_Parser parser,
 949                                 const char *start,
 950                                 const char *end,
 951                                 const char **endPtr)
 952 {
 953     return doContent(parser, 0, encoding, start, end, endPtr);
 954 }
 955
 956 static
 957 enum XML_Error externalEntityInitProcessor(XML_Parser parser,
 958         const char *start,
 959         const char *end,
 960         const char **endPtr)
 961 {
 962     enum XML_Error result = initializeEncoding(parser);
 963     if (result != XML_ERROR_NONE)
 964         return result;
 965     processor = externalEntityInitProcessor2;
 966     return externalEntityInitProcessor2(parser, start, end, endPtr);
 967 }
 968
 969 static
 970 enum XML_Error externalEntityInitProcessor2(XML_Parser parser,
 971         const char *start,
 972         const char *end,
 973         const char **endPtr)
 974 {
 975     const char *next;
 976     int tok = XmlContentTok(encoding, start, end, &next);
 977     switch (tok) {
 978     case XML_TOK_BOM:
 979         start = next;
 980         break;
 981     case XML_TOK_PARTIAL:
 982         if (endPtr) {
 983             *endPtr = start;
 984             return XML_ERROR_NONE;
 985         }
 986         eventPtr = start;
 987         return XML_ERROR_UNCLOSED_TOKEN;
 988     case XML_TOK_PARTIAL_CHAR:
 989         if (endPtr) {
 990             *endPtr = start;
 991             return XML_ERROR_NONE;
 992         }
 993         eventPtr = start;
 994         return XML_ERROR_PARTIAL_CHAR;
 995     }
 996     processor = externalEntityInitProcessor3;
 997     return externalEntityInitProcessor3(parser, start, end, endPtr);
 998 }
 999
1000 static
1001 enum XML_Error externalEntityInitProcessor3(XML_Parser parser,
1002         const char *start,
1003         const char *end,
1004         const char **endPtr)
1005 {
1006     const char *next;
1007     int tok = XmlContentTok(encoding, start, end, &next);
1008     switch (tok) {
1009     case XML_TOK_XML_DECL:
1010         {
1011             enum XML_Error result = processXmlDecl(parser, 1, start, next);
1012             if (result != XML_ERROR_NONE)
1013                 return result;
1014             start = next;
1015         }
1016         break;
1017     case XML_TOK_PARTIAL:
1018         if (endPtr) {
1019             *endPtr = start;
1020             return XML_ERROR_NONE;
1021         }
1022         eventPtr = start;
1023         return XML_ERROR_UNCLOSED_TOKEN;
1024     case XML_TOK_PARTIAL_CHAR:
1025         if (endPtr) {
1026             *endPtr = start;
1027             return XML_ERROR_NONE;
1028         }
1029         eventPtr = start;
1030         return XML_ERROR_PARTIAL_CHAR;
1031     }
1032     processor = externalEntityContentProcessor;
1033     tagLevel = 1;
1034     return doContent(parser, 1, encoding, start, end, endPtr);
1035 }
1036
1037 static
1038 enum XML_Error externalEntityContentProcessor(XML_Parser parser,
1039         const char *start,
1040         const char *end,
1041         const char **endPtr)
1042 {
1043     return doContent(parser, 1, encoding, start, end, endPtr);
1044 }
1045
1046 static enum XML_Error
1047 doContent(XML_Parser parser,
1048           int startTagLevel,
1049           const ENCODING *enc,
1050           const char *s,
1051           const char *end,
1052           const char **nextPtr)
1053 {
1054     const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
1055     const char **eventPP;
1056     const char **eventEndPP;
1057     if (enc == encoding) {
1058         eventPP = &eventPtr;
1059         eventEndPP = &eventEndPtr;
1060     }
1061     else {
1062         eventPP = &(openInternalEntities->internalEventPtr);
1063         eventEndPP = &(openInternalEntities->internalEventEndPtr);
1064     }
1065     *eventPP = s;
1066     for (;;) {
1067         const char *next = s; /* XmlContentTok doesn't always set the last arg */
1068         int tok = XmlContentTok(enc, s, end, &next);
1069         *eventEndPP = next;
1070         switch (tok) {
1071         case XML_TOK_TRAILING_CR:
1072             if (nextPtr) {
1073                 *nextPtr = s;
1074                 return XML_ERROR_NONE;
1075             }
1076             *eventEndPP = end;
1077             if (characterDataHandler) {
1078                 XML_Char c = 0xA;
1079                 characterDataHandler(handlerArg, &c, 1);
1080             }
1081             else if (defaultHandler)
1082                 reportDefault(parser, enc, s, end);
1083             if (startTagLevel == 0)
1084                 return XML_ERROR_NO_ELEMENTS;
1085             if (tagLevel != startTagLevel)
1086                 return XML_ERROR_ASYNC_ENTITY;
1087             return XML_ERROR_NONE;
1088         case XML_TOK_NONE:
1089             if (nextPtr) {
1090                 *nextPtr = s;
1091                 return XML_ERROR_NONE;
1092             }
1093             if (startTagLevel > 0) {
1094                 if (tagLevel != startTagLevel)
1095                     return XML_ERROR_ASYNC_ENTITY;
1096                 return XML_ERROR_NONE;
1097             }
1098             return XML_ERROR_NO_ELEMENTS;
1099         case XML_TOK_INVALID:
1100             *eventPP = next;
1101             return XML_ERROR_INVALID_TOKEN;
1102         case XML_TOK_PARTIAL:
1103             if (nextPtr) {
1104                 *nextPtr = s;
1105                 return XML_ERROR_NONE;
1106             }
1107             return XML_ERROR_UNCLOSED_TOKEN;
1108         case XML_TOK_PARTIAL_CHAR:
1109             if (nextPtr) {
1110                 *nextPtr = s;
1111                 return XML_ERROR_NONE;
1112             }
1113             return XML_ERROR_PARTIAL_CHAR;
1114         case XML_TOK_ENTITY_REF:
1115             {
1116                 const XML_Char *name;
1117                 ENTITY *entity;
1118                 XML_Char ch = XmlPredefinedEntityName(enc,
1119                                                       s + enc->minBytesPerChar,
1120                                                       next - enc->minBytesPerChar);
1121                 if (ch) {
1122                     if (characterDataHandler)
1123                         characterDataHandler(handlerArg, &ch, 1);
1124                     else if (defaultHandler)
1125                         reportDefault(parser, enc, s, next);
1126                     break;
1127                 }
1128                 name = poolStoreString(&dtd.pool, enc,
1129                                        s + enc->minBytesPerChar,
1130                                        next - enc->minBytesPerChar);
1131                 if (!name)
1132                     return XML_ERROR_NO_MEMORY;
1133                 entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
1134                 poolDiscard(&dtd.pool);
1135                 if (!entity) {
1136                     if (dtd.complete || dtd.standalone)
1137                         return XML_ERROR_UNDEFINED_ENTITY;
1138                     if (defaultHandler)
1139                         reportDefault(parser, enc, s, next);
1140                     break;
1141                 }
1142                 if (entity->open)
1143                     return XML_ERROR_RECURSIVE_ENTITY_REF;
1144                 if (entity->notation)
1145                     return XML_ERROR_BINARY_ENTITY_REF;
1146                 if (entity) {
1147                     if (entity->textPtr) {
1148                         enum XML_Error result;
1149                         OPEN_INTERNAL_ENTITY openEntity;
1150                         if (defaultHandler && !defaultExpandInternalEntities) {
1151                             reportDefault(parser, enc, s, next);
1152                             break;
1153                         }
1154                         entity->open = 1;
1155                         openEntity.next = openInternalEntities;
1156                         openInternalEntities = &openEntity;
1157                         openEntity.entity = entity;
1158                         openEntity.internalEventPtr = 0;
1159                         openEntity.internalEventEndPtr = 0;
1160                         result = doContent(parser,
1161                                            tagLevel,
1162                                            internalEnc,
1163                                            (char *)entity->textPtr,
1164                                            (char *)(entity->textPtr + entity->textLen),
1165                                            0);
1166                         entity->open = 0;
1167                         openInternalEntities = openEntity.next;
1168                         if (result)
1169                             return result;
1170                     }
1171                     else if (externalEntityRefHandler) {
1172                         const XML_Char *context;
1173                         entity->open = 1;
1174                         context = getContext(parser);
1175                         entity->open = 0;
1176                         if (!context)
1177                             return XML_ERROR_NO_MEMORY;
1178                         if (!externalEntityRefHandler(externalEntityRefHandlerArg,
1179                                                       context,
1180                                                       dtd.base,
1181                                                       entity->systemId,
1182                                                       entity->publicId))
1183                             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
1184                         poolDiscard(&tempPool);
1185                     }
1186                     else if (defaultHandler)
1187                         reportDefault(parser, enc, s, next);
1188                 }
1189                 break;
1190             }
1191         case XML_TOK_START_TAG_WITH_ATTS:
1192             if (!startElementHandler) {
1193                 enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
1194                 if (result)
1195                     return result;
1196             }
1197             /* fall through */
1198         case XML_TOK_START_TAG_NO_ATTS:
1199             {
1200                 TAG *tag;
1201                 if (freeTagList) {
1202                     tag = freeTagList;
1203                     freeTagList = freeTagList->parent;
1204                 }
1205                 else {
1206                     tag = malloc(sizeof(TAG));
1207                     if (!tag)
1208                         return XML_ERROR_NO_MEMORY;
1209                     tag->buf = malloc(INIT_TAG_BUF_SIZE);
1210                     if (!tag->buf)
1211                         return XML_ERROR_NO_MEMORY;
1212                     tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
1213                 }
1214                 tag->bindings = 0;
1215                 tag->parent = tagStack;
1216                 tagStack = tag;
1217                 tag->name.localPart = 0;
1218                 tag->rawName = s + enc->minBytesPerChar;
1219                 tag->rawNameLength = XmlNameLength(enc, tag->rawName);
1220                 if (nextPtr) {
1221                     /* Need to guarantee that:
1222                        tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)) <= tag->bufEnd - sizeof(XML_Char) */
1223                     if (tag->rawNameLength + (int)(sizeof(XML_Char) - 1) + (int)sizeof(XML_Char) > tag->bufEnd - tag->buf) {
1224                         int bufSize = tag->rawNameLength * 4;
1225                         bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
1226                         tag->buf = realloc(tag->buf, bufSize);
1227                         if (!tag->buf)
1228                             return XML_ERROR_NO_MEMORY;
1229                         tag->bufEnd = tag->buf + bufSize;
1230                     }
1231                     memcpy(tag->buf, tag->rawName, tag->rawNameLength);
1232                     tag->rawName = tag->buf;
1233                 }
1234                 ++tagLevel;
1235                 if (startElementHandler) {
1236                     enum XML_Error result;
1237                     XML_Char *toPtr;
1238                     for (;;) {
1239                         const char *rawNameEnd = tag->rawName + tag->rawNameLength;
1240                         const char *fromPtr = tag->rawName;
1241                         int bufSize;
1242                         if (nextPtr)
1243                             toPtr = (XML_Char *)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
1244                         else
1245                             toPtr = (XML_Char *)tag->buf;
1246                         tag->name.str = toPtr;
1247                         XmlConvert(enc,
1248                                    &fromPtr, rawNameEnd,
1249                                    (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
1250                         if (fromPtr == rawNameEnd)
1251                             break;
1252                         bufSize = (tag->bufEnd - tag->buf) << 1;
1253                         tag->buf = realloc(tag->buf, bufSize);
1254                         if (!tag->buf)
1255                             return XML_ERROR_NO_MEMORY;
1256                         tag->bufEnd = tag->buf + bufSize;
1257                         if (nextPtr)
1258                             tag->rawName = tag->buf;
1259                     }
1260                     *toPtr = XML_T('\0');
1261                     result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
1262                     if (result)
1263                         return result;
1264                     startElementHandler(handlerArg, tag->name.str, (const XML_Char **)atts);
1265                     poolClear(&tempPool);
1266                 }
1267                 else {
1268                     tag->name.str = 0;
1269                     if (defaultHandler)
1270                         reportDefault(parser, enc, s, next);
1271                 }
1272                 break;
1273             }
1274         case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
1275             if (!startElementHandler) {
1276                 enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
1277                 if (result)
1278                     return result;
1279             }
1280             /* fall through */
1281         case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
1282             if (startElementHandler || endElementHandler) {
1283                 const char *rawName = s + enc->minBytesPerChar;
1284                 enum XML_Error result;
1285                 BINDING *bindings = 0;
1286                 TAG_NAME name;
1287                 name.str = poolStoreString(&tempPool, enc, rawName,
1288                                            rawName + XmlNameLength(enc, rawName));
1289                 if (!name.str)
1290                     return XML_ERROR_NO_MEMORY;
1291                 poolFinish(&tempPool);
1292                 result = storeAtts(parser, enc, s, &name, &bindings);
1293                 if (result)
1294                     return result;
1295                 poolFinish(&tempPool);
1296                 if (startElementHandler)
1297                     startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
1298                 if (endElementHandler) {
1299                     if (startElementHandler)
1300                         *eventPP = *eventEndPP;
1301                     endElementHandler(handlerArg, name.str);
1302                 }
1303                 poolClear(&tempPool);
1304                 while (bindings) {
1305                     BINDING *b = bindings;
1306                     if (endNamespaceDeclHandler)
1307                         endNamespaceDeclHandler(handlerArg, b->prefix->name);
1308                     bindings = bindings->nextTagBinding;
1309                     b->nextTagBinding = freeBindingList;
1310                     freeBindingList = b;
1311                     b->prefix->binding = b->prevPrefixBinding;
1312                 }
1313             }
1314             else if (defaultHandler)
1315                 reportDefault(parser, enc, s, next);
1316             if (tagLevel == 0)
1317                 return epilogProcessor(parser, next, end, nextPtr);
1318             break;
1319         case XML_TOK_END_TAG:
1320             if (tagLevel == startTagLevel)
1321                 return XML_ERROR_ASYNC_ENTITY;
1322             else {
1323                 int len;
1324                 const char *rawName;
1325                 TAG *tag = tagStack;
1326                 tagStack = tag->parent;
1327                 tag->parent = freeTagList;
1328                 freeTagList = tag;
1329                 rawName = s + enc->minBytesPerChar*2;
1330                 len = XmlNameLength(enc, rawName);
1331                 if (len != tag->rawNameLength
1332                         || memcmp(tag->rawName, rawName, len) != 0) {
1333                     *eventPP = rawName;
1334                     return XML_ERROR_TAG_MISMATCH;
1335                 }
1336                 --tagLevel;
1337                 if (endElementHandler && tag->name.str) {
1338                     if (tag->name.localPart) {
1339                         XML_Char *to = (XML_Char *)tag->name.str + tag->name.uriLen;
1340                         const XML_Char *from = tag->name.localPart;
1341                         while ((*to++ = *from++) != 0)
1342                             ;
1343                     }
1344                     endElementHandler(handlerArg, tag->name.str);
1345                 }
1346                 else if (defaultHandler)
1347                     reportDefault(parser, enc, s, next);
1348                 while (tag->bindings) {
1349                     BINDING *b = tag->bindings;
1350                     if (endNamespaceDeclHandler)
1351                         endNamespaceDeclHandler(handlerArg, b->prefix->name);
1352                     tag->bindings = tag->bindings->nextTagBinding;
1353                     b->nextTagBinding = freeBindingList;
1354                     freeBindingList = b;
1355                     b->prefix->binding = b->prevPrefixBinding;
1356                 }
1357                 if (tagLevel == 0)
1358                     return epilogProcessor(parser, next, end, nextPtr);
1359             }
1360             break;
1361         case XML_TOK_CHAR_REF:
1362             {
1363                 int n = XmlCharRefNumber(enc, s);
1364                 if (n < 0)
1365                     return XML_ERROR_BAD_CHAR_REF;
1366                 if (characterDataHandler) {
1367                     XML_Char buf[XML_ENCODE_MAX];
1368                     characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
1369                 }
1370                 else if (defaultHandler)
1371                     reportDefault(parser, enc, s, next);
1372             }
1373             break;
1374         case XML_TOK_XML_DECL:
1375             return XML_ERROR_MISPLACED_XML_PI;
1376         case XML_TOK_DATA_NEWLINE:
1377             if (characterDataHandler) {
1378                 XML_Char c = 0xA;
1379                 characterDataHandler(handlerArg, &c, 1);
1380             }
1381             else if (defaultHandler)
1382                 reportDefault(parser, enc, s, next);
1383             break;
1384         case XML_TOK_CDATA_SECT_OPEN:
1385             {
1386                 enum XML_Error result;
1387                 if (startCdataSectionHandler)
1388                     startCdataSectionHandler(handlerArg);
1389 #if 0
1390                 /* Suppose you doing a transformation on a document that involves
1391                    changing only the character data.  You set up a defaultHandler
1392                    and a characterDataHandler.  The defaultHandler simply copies
1393                    characters through.  The characterDataHandler does the transformation
1394                    and writes the characters out escaping them as necessary.  This case
1395                    will fail to work if we leave out the following two lines (because &
1396                    and < inside CDATA sections will be incorrectly escaped).
1397
1398                    However, now we have a start/endCdataSectionHandler, so it seems
1399                    easier to let the user deal with this. */
1400
1401                 else if (characterDataHandler)
1402                     characterDataHandler(handlerArg, dataBuf, 0);
1403 #endif
1404                 else if (defaultHandler)
1405                     reportDefault(parser, enc, s, next);
1406                 result = doCdataSection(parser, enc, &next, end, nextPtr);
1407                 if (!next) {
1408                     processor = cdataSectionProcessor;
1409                     return result;
1410                 }
1411             }
1412             break;
1413         case XML_TOK_TRAILING_RSQB:
1414             if (nextPtr) {
1415                 *nextPtr = s;
1416                 return XML_ERROR_NONE;
1417             }
1418             if (characterDataHandler) {
1419                 if (MUST_CONVERT(enc, s)) {
1420                     ICHAR *dataPtr = (ICHAR *)dataBuf;
1421                     XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
1422                     characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
1423                 }
1424                 else
1425                     characterDataHandler(handlerArg,
1426                                          (XML_Char *)s,
1427                                          (XML_Char *)end - (XML_Char *)s);
1428             }
1429             else if (defaultHandler)
1430                 reportDefault(parser, enc, s, end);
1431             if (startTagLevel == 0) {
1432                 *eventPP = end;
1433                 return XML_ERROR_NO_ELEMENTS;
1434             }
1435             if (tagLevel != startTagLevel) {
1436                 *eventPP = end;
1437                 return XML_ERROR_ASYNC_ENTITY;
1438             }
1439             return XML_ERROR_NONE;
1440         case XML_TOK_DATA_CHARS:
1441             if (characterDataHandler) {
1442                 if (MUST_CONVERT(enc, s)) {
1443                     for (;;) {
1444                         ICHAR *dataPtr = (ICHAR *)dataBuf;
1445                         XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
1446                         *eventEndPP = s;
1447                         characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
1448                         if (s == next)
1449                             break;
1450                         *eventPP = s;
1451                     }
1452                 }
1453                 else
1454                     characterDataHandler(handlerArg,
1455                                          (XML_Char *)s,
1456                                          (XML_Char *)next - (XML_Char *)s);
1457             }
1458             else if (defaultHandler)
1459                 reportDefault(parser, enc, s, next);
1460             break;
1461         case XML_TOK_PI:
1462             if (!reportProcessingInstruction(parser, enc, s, next))
1463                 return XML_ERROR_NO_MEMORY;
1464             break;
1465         case XML_TOK_COMMENT:
1466             if (!reportComment(parser, enc, s, next))
1467                 return XML_ERROR_NO_MEMORY;
1468             break;
1469         default:
1470             if (defaultHandler)
1471                 reportDefault(parser, enc, s, next);
1472             break;
1473         }
1474         *eventPP = s = next;
1475     }
1476     /* not reached */
1477 }
1478
1479 /* If tagNamePtr is non-null, build a real list of attributes,
1480 otherwise just check the attributes for well-formedness. */
1481
1482 static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *enc,
1483                                 const char *s, TAG_NAME *tagNamePtr,
1484                                 BINDING **bindingsPtr)
1485 {
1486     ELEMENT_TYPE *elementType = 0;
1487     int nDefaultAtts = 0;
1488     const XML_Char **appAtts;
1489     int attIndex = 0;
1490     int i;
1491     int n;
1492     int nPrefixes = 0;
1493     BINDING *binding;
1494     const XML_Char *localPart;
1495
1496     if (tagNamePtr) {
1497         elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, 0);
1498         if (!elementType) {
1499             tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str);
1500             if (!tagNamePtr->str)
1501                 return XML_ERROR_NO_MEMORY;
1502             elementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
1503             if (!elementType)
1504                 return XML_ERROR_NO_MEMORY;
1505             if (ns && !setElementTypePrefix(parser, elementType))
1506                 return XML_ERROR_NO_MEMORY;
1507         }
1508         nDefaultAtts = elementType->nDefaultAtts;
1509     }
1510     n = XmlGetAttributes(enc, s, attsSize, atts);
1511     if (n + nDefaultAtts > attsSize) {
1512         int oldAttsSize = attsSize;
1513         attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
1514         atts = realloc((void *)atts, attsSize * sizeof(ATTRIBUTE));
1515         if (!atts)
1516             return XML_ERROR_NO_MEMORY;
1517         if (n > oldAttsSize)
1518             XmlGetAttributes(enc, s, n, atts);
1519     }
1520     appAtts = (const XML_Char **)atts;
1521     for (i = 0; i < n; i++) {
1522         ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,
1523                                              atts[i].name
1524                                              + XmlNameLength(enc, atts[i].name));
1525         if (!attId)
1526             return XML_ERROR_NO_MEMORY;
1527         if ((attId->name)[-1]) {
1528             if (enc == encoding)
1529                 eventPtr = atts[i].name;
1530             return XML_ERROR_DUPLICATE_ATTRIBUTE;
1531         }
1532         (attId->name)[-1] = 1;
1533         appAtts[attIndex++] = attId->name;
1534         if (!atts[i].normalized) {
1535             enum XML_Error result;
1536             int isCdata = 1;
1537
1538             if (attId->maybeTokenized) {
1539                 int j;
1540                 for (j = 0; j < nDefaultAtts; j++) {
1541                     if (attId == elementType->defaultAtts[j].id) {
1542                         isCdata = elementType->defaultAtts[j].isCdata;
1543                         break;
1544                     }
1545                 }
1546             }
1547
1548             result = storeAttributeValue(parser, enc, isCdata,
1549                                          atts[i].valuePtr, atts[i].valueEnd,
1550                                          &tempPool);
1551             if (result)
1552                 return result;
1553             if (tagNamePtr) {
1554                 appAtts[attIndex] = poolStart(&tempPool);
1555                 poolFinish(&tempPool);
1556             }
1557             else
1558                 poolDiscard(&tempPool);
1559         }
1560         else if (tagNamePtr) {
1561             appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
1562             if (appAtts[attIndex] == 0)
1563                 return XML_ERROR_NO_MEMORY;
1564             poolFinish(&tempPool);
1565         }
1566         if (attId->prefix && tagNamePtr) {
1567             if (attId->xmlns) {
1568                 if (!addBinding(parser, attId->prefix, attId, appAtts[attIndex], bindingsPtr))
1569                     return XML_ERROR_NO_MEMORY;
1570                 --attIndex;
1571             }
1572             else {
1573                 attIndex++;
1574                 nPrefixes++;
1575                 (attId->name)[-1] = 2;
1576             }
1577         }
1578         else
1579             attIndex++;
1580     }
1581     nSpecifiedAtts = attIndex;
1582     if (tagNamePtr) {
1583         int j;
1584         for (j = 0; j < nDefaultAtts; j++) {
1585             const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + j;
1586             if (!(da->id->name)[-1] && da->value) {
1587                 if (da->id->prefix) {
1588                     if (da->id->xmlns) {
1589                         if (!addBinding(parser, da->id->prefix, da->id, da->value, bindingsPtr))
1590                             return XML_ERROR_NO_MEMORY;
1591                     }
1592                     else {
1593                         (da->id->name)[-1] = 2;
1594                         nPrefixes++;
1595                         appAtts[attIndex++] = da->id->name;
1596                         appAtts[attIndex++] = da->value;
1597                     }
1598                 }
1599                 else {
1600                     (da->id->name)[-1] = 1;
1601                     appAtts[attIndex++] = da->id->name;
1602                     appAtts[attIndex++] = da->value;
1603                 }
1604             }
1605         }
1606         appAtts[attIndex] = 0;
1607     }
1608     i = 0;
1609     if (nPrefixes) {
1610         for (; i < attIndex; i += 2) {
1611             if (appAtts[i][-1] == 2) {
1612                 ATTRIBUTE_ID *id;
1613                 ((XML_Char *)(appAtts[i]))[-1] = 0;
1614                 id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, appAtts[i], 0);
1615                 if (id->prefix->binding) {
1616                     int j;
1617                     const BINDING *b = id->prefix->binding;
1618                     const XML_Char *s = appAtts[i];
1619                     for (j = 0; j < b->uriLen; j++) {
1620                         if (!poolAppendChar(&tempPool, b->uri[j]))
1621                             return XML_ERROR_NO_MEMORY;
1622                     }
1623                     while (*s++ != ':')
1624                         ;
1625                     do {
1626                         if (!poolAppendChar(&tempPool, *s))
1627                             return XML_ERROR_NO_MEMORY;
1628                     } while (*s++);
1629                     appAtts[i] = poolStart(&tempPool);
1630                     poolFinish(&tempPool);
1631                 }
1632                 if (!--nPrefixes)
1633                     break;
1634             }
1635             else
1636                 ((XML_Char *)(appAtts[i]))[-1] = 0;
1637         }
1638     }
1639     for (; i < attIndex; i += 2)
1640         ((XML_Char *)(appAtts[i]))[-1] = 0;
1641     if (!tagNamePtr)
1642         return XML_ERROR_NONE;
1643     for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
1644         binding->attId->name[-1] = 0;
1645     if (elementType->prefix) {
1646         binding = elementType->prefix->binding;
1647         if (!binding)
1648             return XML_ERROR_NONE;
1649         localPart = tagNamePtr->str;
1650         while (*localPart++ != XML_T(':'))
1651             ;
1652     }
1653     else if (dtd.defaultPrefix.binding) {
1654         binding = dtd.defaultPrefix.binding;
1655         localPart = tagNamePtr->str;
1656     }
1657     else
1658         return XML_ERROR_NONE;
1659     tagNamePtr->localPart = localPart;
1660     tagNamePtr->uriLen = binding->uriLen;
1661     i = binding->uriLen;
1662     do {
1663         if (i == binding->uriAlloc) {
1664             binding->uri = realloc(binding->uri, binding->uriAlloc *= 2);
1665             if (!binding->uri)
1666                 return XML_ERROR_NO_MEMORY;
1667         }
1668         binding->uri[i++] = *localPart;
1669     } while (*localPart++);
1670     tagNamePtr->str = binding->uri;
1671     return XML_ERROR_NONE;
1672 }
1673
1674 static
1675 int addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, const XML_Char *uri, BINDING **bindingsPtr)
1676 {
1677     BINDING *b;
1678     int len;
1679     for (len = 0; uri[len]; len++)
1680         ;
1681     if (namespaceSeparator)
1682         len++;
1683     if (freeBindingList) {
1684         b = freeBindingList;
1685         if (len > b->uriAlloc) {
1686             b->uri = realloc(b->uri, len + EXPAND_SPARE);
1687             if (!b->uri)
1688                 return 0;
1689             b->uriAlloc = len + EXPAND_SPARE;
1690         }
1691         freeBindingList = b->nextTagBinding;
1692     }
1693     else {
1694         b = malloc(sizeof(BINDING));
1695         if (!b)
1696             return 0;
1697         b->uri = malloc(sizeof(XML_Char) * len + EXPAND_SPARE);
1698         if (!b->uri) {
1699             free(b);
1700             return 0;
1701         }
1702         b->uriAlloc = len;
1703     }
1704     b->uriLen = len;
1705     memcpy(b->uri, uri, len * sizeof(XML_Char));
1706     if (namespaceSeparator)
1707         b->uri[len - 1] = namespaceSeparator;
1708     b->prefix = prefix;
1709     b->attId = attId;
1710     b->prevPrefixBinding = prefix->binding;
1711     if (*uri == XML_T('\0') && prefix == &dtd.defaultPrefix)
1712         prefix->binding = 0;
1713     else
1714         prefix->binding = b;
1715     b->nextTagBinding = *bindingsPtr;
1716     *bindingsPtr = b;
1717     if (startNamespaceDeclHandler)
1718         startNamespaceDeclHandler(handlerArg, prefix->name,
1719                                   prefix->binding ? uri : 0);
1720     return 1;
1721 }
1722
1723 /* The idea here is to avoid using stack for each CDATA section when
1724 the whole file is parsed with one call. */
1725
1726 static
1727 enum XML_Error cdataSectionProcessor(XML_Parser parser,
1728                                      const char *start,
1729                                      const char *end,
1730                                      const char **endPtr)
1731 {
1732     enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr);
1733     if (start) {
1734         processor = contentProcessor;
1735         return contentProcessor(parser, start, end, endPtr);
1736     }
1737     return result;
1738 }
1739
1740 /* startPtr gets set to non-null is the section is closed, and to null if
1741 the section is not yet closed. */
1742
1743 static
1744 enum XML_Error doCdataSection(XML_Parser parser,
1745                               const ENCODING *enc,
1746                               const char **startPtr,
1747                               const char *end,
1748                               const char **nextPtr)
1749 {
1750     const char *s = *startPtr;
1751     const char **eventPP;
1752     const char **eventEndPP;
1753     if (enc == encoding) {
1754         eventPP = &eventPtr;
1755         *eventPP = s;
1756         eventEndPP = &eventEndPtr;
1757     }
1758     else {
1759         eventPP = &(openInternalEntities->internalEventPtr);
1760         eventEndPP = &(openInternalEntities->internalEventEndPtr);
1761     }
1762     *eventPP = s;
1763     *startPtr = 0;
1764     for (;;) {
1765         const char *next;
1766         int tok = XmlCdataSectionTok(enc, s, end, &next);
1767         *eventEndPP = next;
1768         switch (tok) {
1769         case XML_TOK_CDATA_SECT_CLOSE:
1770             if (endCdataSectionHandler)
1771                 endCdataSectionHandler(handlerArg);
1772 #if 0
1773             /* see comment under XML_TOK_CDATA_SECT_OPEN */
1774             else if (characterDataHandler)
1775                 characterDataHandler(handlerArg, dataBuf, 0);
1776 #endif
1777             else if (defaultHandler)
1778                 reportDefault(parser, enc, s, next);
1779             *startPtr = next;
1780             return XML_ERROR_NONE;
1781         case XML_TOK_DATA_NEWLINE:
1782             if (characterDataHandler) {
1783                 XML_Char c = 0xA;
1784                 characterDataHandler(handlerArg, &c, 1);
1785             }
1786             else if (defaultHandler)
1787                 reportDefault(parser, enc, s, next);
1788             break;
1789         case XML_TOK_DATA_CHARS:
1790             if (characterDataHandler) {
1791                 if (MUST_CONVERT(enc, s)) {
1792                     for (;;) {
1793                         ICHAR *dataPtr = (ICHAR *)dataBuf;
1794                         XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
1795                         *eventEndPP = next;
1796                         characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
1797                         if (s == next)
1798                             break;
1799                         *eventPP = s;
1800                     }
1801                 }
1802                 else
1803                     characterDataHandler(handlerArg,
1804                                          (XML_Char *)s,
1805                                          (XML_Char *)next - (XML_Char *)s);
1806             }
1807             else if (defaultHandler)
1808                 reportDefault(parser, enc, s, next);
1809             break;
1810         case XML_TOK_INVALID:
1811             *eventPP = next;
1812             return XML_ERROR_INVALID_TOKEN;
1813         case XML_TOK_PARTIAL_CHAR:
1814             if (nextPtr) {
1815                 *nextPtr = s;
1816                 return XML_ERROR_NONE;
1817             }
1818             return XML_ERROR_PARTIAL_CHAR;
1819         case XML_TOK_PARTIAL:
1820         case XML_TOK_NONE:
1821             if (nextPtr) {
1822                 *nextPtr = s;
1823                 return XML_ERROR_NONE;
1824             }
1825             return XML_ERROR_UNCLOSED_CDATA_SECTION;
1826         default:
1827             abort();
1828         }
1829         *eventPP = s = next;
1830     }
1831     /* not reached */
1832 }
1833
1834 static enum XML_Error
1835 initializeEncoding(XML_Parser parser)
1836 {
1837     const char *s;
1838 #ifdef XML_UNICODE
1839     char encodingBuf[128];
1840     if (!protocolEncodingName)
1841         s = 0;
1842     else {
1843         int i;
1844         for (i = 0; protocolEncodingName[i]; i++) {
1845             if (i == sizeof(encodingBuf) - 1
1846                     || protocolEncodingName[i] >= 0x80
1847                     || protocolEncodingName[i] < 0) {
1848                 encodingBuf[0] = '\0';
1849                 break;
1850             }
1851             encodingBuf[i] = (char)protocolEncodingName[i];
1852         }
1853         encodingBuf[i] = '\0';
1854         s = encodingBuf;
1855     }
1856 #else
1857 s = protocolEncodingName;
1858 #endif
1859     if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
1860         return XML_ERROR_NONE;
1861     return handleUnknownEncoding(parser, protocolEncodingName);
1862 }
1863
1864 static enum XML_Error
1865 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
1866                const char *s, const char *next)
1867 {
1868     const char *encodingName = 0;
1869     const ENCODING *newEncoding = 0;
1870     const char *version;
1871     int standalone = -1;
1872     if (!(ns
1873             ? XmlParseXmlDeclNS
1874             : XmlParseXmlDecl)(isGeneralTextEntity,
1875                                encoding,
1876                                s,
1877                                next,
1878                                &eventPtr,
1879                                &version,
1880                                &encodingName,
1881                                &newEncoding,
1882                                &standalone))
1883         return XML_ERROR_SYNTAX;
1884     if (!isGeneralTextEntity && standalone == 1)
1885         dtd.standalone = 1;
1886     if (defaultHandler)
1887         reportDefault(parser, encoding, s, next);
1888     if (!protocolEncodingName) {
1889         if (newEncoding) {
1890             if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
1891                 eventPtr = encodingName;
1892                 return XML_ERROR_INCORRECT_ENCODING;
1893             }
1894             encoding = newEncoding;
1895         }
1896         else if (encodingName) {
1897             enum XML_Error result;
1898             const XML_Char *s = poolStoreString(&tempPool,
1899                                                 encoding,
1900                                                 encodingName,
1901                                                 encodingName
1902                                                 + XmlNameLength(encoding, encodingName));
1903             if (!s)
1904                 return XML_ERROR_NO_MEMORY;
1905             result = handleUnknownEncoding(parser, s);
1906             poolDiscard(&tempPool);
1907             if (result == XML_ERROR_UNKNOWN_ENCODING)
1908                 eventPtr = encodingName;
1909             return result;
1910         }
1911     }
1912     return XML_ERROR_NONE;
1913 }
1914
1915 static enum XML_Error
1916 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName)
1917 {
1918     if (unknownEncodingHandler) {
1919         XML_Encoding info;
1920         int i;
1921         for (i = 0; i < 256; i++)
1922             info.map[i] = -1;
1923         info.convert = 0;
1924         info.data = 0;
1925         info.release = 0;
1926         if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info)) {
1927             ENCODING *enc;
1928             unknownEncodingMem = malloc(XmlSizeOfUnknownEncoding());
1929             if (!unknownEncodingMem) {
1930                 if (info.release)
1931                     info.release(info.data);
1932                 return XML_ERROR_NO_MEMORY;
1933             }
1934             enc = (ns
1935                    ? XmlInitUnknownEncodingNS
1936                    : XmlInitUnknownEncoding)(unknownEncodingMem,
1937                                              info.map,
1938                                              info.convert,
1939                                              info.data);
1940             if (enc) {
1941                 unknownEncodingData = info.data;
1942                 unknownEncodingRelease = info.release;
1943                 encoding = enc;
1944                 return XML_ERROR_NONE;
1945             }
1946         }
1947         if (info.release)
1948             info.release(info.data);
1949     }
1950     return XML_ERROR_UNKNOWN_ENCODING;
1951 }
1952
1953 static enum XML_Error
1954 prologInitProcessor(XML_Parser parser,
1955                     const char *s,
1956                     const char *end,
1957                     const char **nextPtr)
1958 {
1959     enum XML_Error result = initializeEncoding(parser);
1960     if (result != XML_ERROR_NONE)
1961         return result;
1962     processor = prologProcessor;
1963     return prologProcessor(parser, s, end, nextPtr);
1964 }
1965
1966 static enum XML_Error
1967 prologProcessor(XML_Parser parser,
1968                 const char *s,
1969                 const char *end,
1970                 const char **nextPtr)
1971 {
1972     for (;;) {
1973         const char *next;
1974         int tok = XmlPrologTok(encoding, s, end, &next);
1975         if (tok <= 0) {
1976             if (nextPtr != 0 && tok != XML_TOK_INVALID) {
1977                 *nextPtr = s;
1978                 return XML_ERROR_NONE;
1979             }
1980             switch (tok) {
1981             case XML_TOK_INVALID:
1982                 eventPtr = next;
1983                 return XML_ERROR_INVALID_TOKEN;
1984             case XML_TOK_NONE:
1985                 return XML_ERROR_NO_ELEMENTS;
1986             case XML_TOK_PARTIAL:
1987                 return XML_ERROR_UNCLOSED_TOKEN;
1988             case XML_TOK_PARTIAL_CHAR:
1989                 return XML_ERROR_PARTIAL_CHAR;
1990             case XML_TOK_TRAILING_CR:
1991                 eventPtr = s + encoding->minBytesPerChar;
1992                 return XML_ERROR_NO_ELEMENTS;
1993             default:
1994                 abort();
1995             }
1996         }
1997         switch (XmlTokenRole(&prologState, tok, s, next, encoding)) {
1998         case XML_ROLE_XML_DECL:
1999             {
2000                 enum XML_Error result = processXmlDecl(parser, 0, s, next);
2001                 if (result != XML_ERROR_NONE)
2002                     return result;
2003             }
2004             break;
2005         case XML_ROLE_DOCTYPE_SYSTEM_ID:
2006             if (!dtd.standalone
2007                     && notStandaloneHandler
2008                     && !notStandaloneHandler(handlerArg))
2009                 return XML_ERROR_NOT_STANDALONE;
2010             hadExternalDoctype = 1;
2011             break;
2012         case XML_ROLE_DOCTYPE_PUBLIC_ID:
2013         case XML_ROLE_ENTITY_PUBLIC_ID:
2014             if (!XmlIsPublicId(encoding, s, next, &eventPtr))
2015                 return XML_ERROR_SYNTAX;
2016             if (declEntity) {
2017                 XML_Char *tem = poolStoreString(&dtd.pool,
2018                                                 encoding,
2019                                                 s + encoding->minBytesPerChar,
2020                                                 next - encoding->minBytesPerChar);
2021                 if (!tem)
2022                     return XML_ERROR_NO_MEMORY;
2023                 normalizePublicId(tem);
2024                 declEntity->publicId = tem;
2025                 poolFinish(&dtd.pool);
2026             }
2027             break;
2028         case XML_ROLE_INSTANCE_START:
2029             processor = contentProcessor;
2030             if (hadExternalDoctype)
2031                 dtd.complete = 0;
2032             return contentProcessor(parser, s, end, nextPtr);
2033         case XML_ROLE_ATTLIST_ELEMENT_NAME:
2034             {
2035                 const XML_Char *name = poolStoreString(&dtd.pool, encoding, s, next);
2036                 if (!name)
2037                     return XML_ERROR_NO_MEMORY;
2038                 declElementType = (ELEMENT_TYPE *)lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
2039                 if (!declElementType)
2040                     return XML_ERROR_NO_MEMORY;
2041                 if (declElementType->name != name)
2042                     poolDiscard(&dtd.pool);
2043                 else {
2044                     poolFinish(&dtd.pool);
2045                     if (!setElementTypePrefix(parser, declElementType))
2046                         return XML_ERROR_NO_MEMORY;
2047                 }
2048                 break;
2049             }
2050         case XML_ROLE_ATTRIBUTE_NAME:
2051             declAttributeId = getAttributeId(parser, encoding, s, next);
2052             if (!declAttributeId)
2053                 return XML_ERROR_NO_MEMORY;
2054             declAttributeIsCdata = 0;
2055             break;
2056         case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
2057             declAttributeIsCdata = 1;
2058             break;
2059         case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
2060         case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
2061             if (dtd.complete
2062                     && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0))
2063                 return XML_ERROR_NO_MEMORY;
2064             break;
2065         case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
2066         case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
2067             {
2068                 const XML_Char *attVal;
2069                 enum XML_Error result
2070                 = storeAttributeValue(parser, encoding, declAttributeIsCdata,
2071                                       s + encoding->minBytesPerChar,
2072                                       next - encoding->minBytesPerChar,
2073                                       &dtd.pool);
2074                 if (result)
2075                     return result;
2076                 attVal = poolStart(&dtd.pool);
2077                 poolFinish(&dtd.pool);
2078                 if (dtd.complete
2079                         && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, attVal))
2080                     return XML_ERROR_NO_MEMORY;
2081                 break;
2082             }
2083         case XML_ROLE_ENTITY_VALUE:
2084             {
2085                 enum XML_Error result = storeEntityValue(parser, s, next);
2086                 if (result != XML_ERROR_NONE)
2087                     return result;
2088             }
2089             break;
2090         case XML_ROLE_ENTITY_SYSTEM_ID:
2091             if (declEntity) {
2092                 declEntity->systemId = poolStoreString(&dtd.pool, encoding,
2093                                                        s + encoding->minBytesPerChar,
2094                                                        next - encoding->minBytesPerChar);
2095                 if (!declEntity->systemId)
2096                     return XML_ERROR_NO_MEMORY;
2097                 declEntity->base = dtd.base;
2098                 poolFinish(&dtd.pool);
2099             }
2100             break;
2101         case XML_ROLE_ENTITY_NOTATION_NAME:
2102             if (declEntity) {
2103                 declEntity->notation = poolStoreString(&dtd.pool, encoding, s, next);
2104                 if (!declEntity->notation)
2105                     return XML_ERROR_NO_MEMORY;
2106                 poolFinish(&dtd.pool);
2107                 if (unparsedEntityDeclHandler) {
2108                     eventPtr = eventEndPtr = s;
2109                     unparsedEntityDeclHandler(handlerArg,
2110                                               declEntity->name,
2111                                               declEntity->base,
2112                                               declEntity->systemId,
2113                                               declEntity->publicId,
2114                                               declEntity->notation);
2115                 }
2116
2117             }
2118             break;
2119         case XML_ROLE_GENERAL_ENTITY_NAME:
2120             {
2121                 const XML_Char *name;
2122                 if (XmlPredefinedEntityName(encoding, s, next)) {
2123                     declEntity = 0;
2124                     break;
2125                 }
2126                 name = poolStoreString(&dtd.pool, encoding, s, next);
2127                 if (!name)
2128                     return XML_ERROR_NO_MEMORY;
2129                 if (dtd.complete) {
2130                     declEntity = (ENTITY *)lookup(&dtd.generalEntities, name, sizeof(ENTITY));
2131                     if (!declEntity)
2132                         return XML_ERROR_NO_MEMORY;
2133                     if (declEntity->name != name) {
2134                         poolDiscard(&dtd.pool);
2135                         declEntity = 0;
2136                     }
2137                     else
2138                         poolFinish(&dtd.pool);
2139                 }
2140                 else {
2141                     poolDiscard(&dtd.pool);
2142                     declEntity = 0;
2143                 }
2144             }
2145             break;
2146         case XML_ROLE_PARAM_ENTITY_NAME:
2147             declEntity = 0;
2148             break;
2149         case XML_ROLE_NOTATION_NAME:
2150             declNotationPublicId = 0;
2151             declNotationName = 0;
2152             if (notationDeclHandler) {
2153                 declNotationName = poolStoreString(&tempPool, encoding, s, next);
2154                 if (!declNotationName)
2155                     return XML_ERROR_NO_MEMORY;
2156                 poolFinish(&tempPool);
2157             }
2158             break;
2159         case XML_ROLE_NOTATION_PUBLIC_ID:
2160             if (!XmlIsPublicId(encoding, s, next, &eventPtr))
2161                 return XML_ERROR_SYNTAX;
2162             if (declNotationName) {
2163                 XML_Char *tem = poolStoreString(&tempPool,
2164                                                 encoding,
2165                                                 s + encoding->minBytesPerChar,
2166                                                 next - encoding->minBytesPerChar);
2167                 if (!tem)
2168                     return XML_ERROR_NO_MEMORY;
2169                 normalizePublicId(tem);
2170                 declNotationPublicId = tem;
2171                 poolFinish(&tempPool);
2172             }
2173             break;
2174         case XML_ROLE_NOTATION_SYSTEM_ID:
2175             if (declNotationName && notationDeclHandler) {
2176                 const XML_Char *systemId
2177                 = poolStoreString(&tempPool, encoding,
2178                                   s + encoding->minBytesPerChar,
2179                                   next - encoding->minBytesPerChar);
2180                 if (!systemId)
2181                     return XML_ERROR_NO_MEMORY;
2182                 eventPtr = eventEndPtr = s;
2183                 notationDeclHandler(handlerArg,
2184                                     declNotationName,
2185                                     dtd.base,
2186                                     systemId,
2187                                     declNotationPublicId);
2188             }
2189             poolClear(&tempPool);
2190             break;
2191         case XML_ROLE_NOTATION_NO_SYSTEM_ID:
2192             if (declNotationPublicId && notationDeclHandler) {
2193                 eventPtr = eventEndPtr = s;
2194                 notationDeclHandler(handlerArg,
2195                                     declNotationName,
2196                                     dtd.base,
2197                                     0,
2198                                     declNotationPublicId);
2199             }
2200             poolClear(&tempPool);
2201             break;
2202         case XML_ROLE_ERROR:
2203             eventPtr = s;
2204             switch (tok) {
2205             case XML_TOK_PARAM_ENTITY_REF:
2206                 return XML_ERROR_PARAM_ENTITY_REF;
2207             case XML_TOK_XML_DECL:
2208                 return XML_ERROR_MISPLACED_XML_PI;
2209             default:
2210                 return XML_ERROR_SYNTAX;
2211             }
2212         case XML_ROLE_GROUP_OPEN:
2213             if (prologState.level >= groupSize) {
2214                 if (groupSize)
2215                     groupConnector = realloc(groupConnector, groupSize *= 2);
2216                 else
2217                     groupConnector = malloc(groupSize = 32);
2218                 if (!groupConnector)
2219                     return XML_ERROR_NO_MEMORY;
2220             }
2221             groupConnector[prologState.level] = 0;
2222             break;
2223         case XML_ROLE_GROUP_SEQUENCE:
2224             if (groupConnector[prologState.level] == '|') {
2225                 eventPtr = s;
2226                 return XML_ERROR_SYNTAX;
2227             }
2228             groupConnector[prologState.level] = ',';
2229             break;
2230         case XML_ROLE_GROUP_CHOICE:
2231             if (groupConnector[prologState.level] == ',') {
2232                 eventPtr = s;
2233                 return XML_ERROR_SYNTAX;
2234             }
2235             groupConnector[prologState.level] = '|';
2236             break;
2237         case XML_ROLE_PARAM_ENTITY_REF:
2238             if (!dtd.standalone
2239                     && notStandaloneHandler
2240                     && !notStandaloneHandler(handlerArg))
2241                 return XML_ERROR_NOT_STANDALONE;
2242             dtd.complete = 0;
2243             break;
2244         case XML_ROLE_NONE:
2245             switch (tok) {
2246             case XML_TOK_PI:
2247                 eventPtr = s;
2248                 eventEndPtr = next;
2249                 if (!reportProcessingInstruction(parser, encoding, s, next))
2250                     return XML_ERROR_NO_MEMORY;
2251                 break;
2252             case XML_TOK_COMMENT:
2253                 eventPtr = s;
2254                 eventEndPtr = next;
2255                 if (!reportComment(parser, encoding, s, next))
2256                     return XML_ERROR_NO_MEMORY;
2257                 break;
2258             }
2259             break;
2260         }
2261         if (defaultHandler) {
2262             switch (tok) {
2263             case XML_TOK_PI:
2264             case XML_TOK_COMMENT:
2265             case XML_TOK_BOM:
2266             case XML_TOK_XML_DECL:
2267                 break;
2268             default:
2269                 eventPtr = s;
2270                 eventEndPtr = next;
2271                 reportDefault(parser, encoding, s, next);
2272             }
2273         }
2274         s = next;
2275     }
2276     /* not reached */
2277 }
2278
2279 static
2280 enum XML_Error epilogProcessor(XML_Parser parser,
2281                                const char *s,
2282                                const char *end,
2283                                const char **nextPtr)
2284 {
2285     processor = epilogProcessor;
2286     eventPtr = s;
2287     for (;;) {
2288         const char *next;
2289         int tok = XmlPrologTok(encoding, s, end, &next);
2290         eventEndPtr = next;
2291         switch (tok) {
2292         case XML_TOK_TRAILING_CR:
2293             if (defaultHandler) {
2294                 eventEndPtr = end;
2295                 reportDefault(parser, encoding, s, end);
2296             }
2297             /* fall through */
2298         case XML_TOK_NONE:
2299             if (nextPtr)
2300                 *nextPtr = end;
2301             return XML_ERROR_NONE;
2302         case XML_TOK_PROLOG_S:
2303             if (defaultHandler)
2304                 reportDefault(parser, encoding, s, next);
2305             break;
2306         case XML_TOK_PI:
2307             if (!reportProcessingInstruction(parser, encoding, s, next))
2308                 return XML_ERROR_NO_MEMORY;
2309             break;
2310         case XML_TOK_COMMENT:
2311             if (!reportComment(parser, encoding, s, next))
2312                 return XML_ERROR_NO_MEMORY;
2313             break;
2314         case XML_TOK_INVALID:
2315             eventPtr = next;
2316             return XML_ERROR_INVALID_TOKEN;
2317         case XML_TOK_PARTIAL:
2318             if (nextPtr) {
2319                 *nextPtr = s;
2320                 return XML_ERROR_NONE;
2321             }
2322             return XML_ERROR_UNCLOSED_TOKEN;
2323         case XML_TOK_PARTIAL_CHAR:
2324             if (nextPtr) {
2325                 *nextPtr = s;
2326                 return XML_ERROR_NONE;
2327             }
2328             return XML_ERROR_PARTIAL_CHAR;
2329         default:
2330             return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
2331         }
2332         eventPtr = s = next;
2333     }
2334 }
2335
2336 static
2337 enum XML_Error errorProcessor(XML_Parser parser,
2338                               const char *s,
2339                               const char *end,
2340                               const char **nextPtr)
2341 {
2342     return errorCode;
2343 }
2344
2345 static enum XML_Error
2346 storeAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
2347                     const char *ptr, const char *end,
2348                     STRING_POOL *pool)
2349 {
2350     enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
2351     if (result)
2352         return result;
2353     if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
2354         poolChop(pool);
2355     if (!poolAppendChar(pool, XML_T('\0')))
2356         return XML_ERROR_NO_MEMORY;
2357     return XML_ERROR_NONE;
2358 }
2359
2360 static enum XML_Error
2361 appendAttributeValue(XML_Parser parser, const ENCODING *enc, int isCdata,
2362                      const char *ptr, const char *end,
2363                      STRING_POOL *pool)
2364 {
2365     const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
2366     for (;;) {
2367         const char *next;
2368         int tok = XmlAttributeValueTok(enc, ptr, end, &next);
2369         switch (tok) {
2370         case XML_TOK_NONE:
2371             return XML_ERROR_NONE;
2372         case XML_TOK_INVALID:
2373             if (enc == encoding)
2374                 eventPtr = next;
2375             return XML_ERROR_INVALID_TOKEN;
2376         case XML_TOK_PARTIAL:
2377             if (enc == encoding)
2378                 eventPtr = ptr;
2379             return XML_ERROR_INVALID_TOKEN;
2380         case XML_TOK_CHAR_REF:
2381             {
2382                 XML_Char buf[XML_ENCODE_MAX];
2383                 int i;
2384                 int n = XmlCharRefNumber(enc, ptr);
2385                 if (n < 0) {
2386                     if (enc == encoding)
2387                         eventPtr = ptr;
2388                     return XML_ERROR_BAD_CHAR_REF;
2389                 }
2390                 if (!isCdata
2391                         && n == 0x20 /* space */
2392                         && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
2393                     break;
2394                 n = XmlEncode(n, (ICHAR *)buf);
2395                 if (!n) {
2396                     if (enc == encoding)
2397                         eventPtr = ptr;
2398                     return XML_ERROR_BAD_CHAR_REF;
2399                 }
2400                 for (i = 0; i < n; i++) {
2401                     if (!poolAppendChar(pool, buf[i]))
2402                         return XML_ERROR_NO_MEMORY;
2403                 }
2404             }
2405             break;
2406         case XML_TOK_DATA_CHARS:
2407             if (!poolAppend(pool, enc, ptr, next))
2408                 return XML_ERROR_NO_MEMORY;
2409             break;
2410             break;
2411         case XML_TOK_TRAILING_CR:
2412             next = ptr + enc->minBytesPerChar;
2413             /* fall through */
2414         case XML_TOK_ATTRIBUTE_VALUE_S:
2415         case XML_TOK_DATA_NEWLINE:
2416             if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
2417                 break;
2418             if (!poolAppendChar(pool, 0x20))
2419                 return XML_ERROR_NO_MEMORY;
2420             break;
2421         case XML_TOK_ENTITY_REF:
2422             {
2423                 const XML_Char *name;
2424                 ENTITY *entity;
2425                 XML_Char ch = XmlPredefinedEntityName(enc,
2426                                                       ptr + enc->minBytesPerChar,
2427                                                       next - enc->minBytesPerChar);
2428                 if (ch) {
2429                     if (!poolAppendChar(pool, ch))
2430                         return XML_ERROR_NO_MEMORY;
2431                     break;
2432                 }
2433                 name = poolStoreString(&temp2Pool, enc,
2434                                        ptr + enc->minBytesPerChar,
2435                                        next - enc->minBytesPerChar);
2436                 if (!name)
2437                     return XML_ERROR_NO_MEMORY;
2438                 entity = (ENTITY *)lookup(&dtd.generalEntities, name, 0);
2439                 poolDiscard(&temp2Pool);
2440                 if (!entity) {
2441                     if (dtd.complete) {
2442                         if (enc == encoding)
2443                             eventPtr = ptr;
2444                         return XML_ERROR_UNDEFINED_ENTITY;
2445                     }
2446                 }
2447                 else if (entity->open) {
2448                     if (enc == encoding)
2449                         eventPtr = ptr;
2450                     return XML_ERROR_RECURSIVE_ENTITY_REF;
2451                 }
2452                 else if (entity->notation) {
2453                     if (enc == encoding)
2454                         eventPtr = ptr;
2455                     return XML_ERROR_BINARY_ENTITY_REF;
2456                 }
2457                 else if (!entity->textPtr) {
2458                     if (enc == encoding)
2459                         eventPtr = ptr;
2460                     return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
2461                 }
2462                 else {
2463                     enum XML_Error result;
2464                     const XML_Char *textEnd = entity->textPtr + entity->textLen;
2465                     entity->open = 1;
2466                     result = appendAttributeValue(parser, internalEnc, isCdata, (char *)entity->textPtr, (char *)textEnd, pool);
2467                     entity->open = 0;
2468                     if (result)
2469                         return result;
2470                 }
2471             }
2472             break;
2473         default:
2474             abort();
2475         }
2476         ptr = next;
2477     }
2478     /* not reached */
2479 }
2480
2481 static
2482 enum XML_Error storeEntityValue(XML_Parser parser,
2483                                 const char *entityTextPtr,
2484                                 const char *entityTextEnd)
2485 {
2486     const ENCODING *internalEnc = ns ? XmlGetInternalEncodingNS() : XmlGetInternalEncoding();
2487     STRING_POOL *pool = &(dtd.pool);
2488     entityTextPtr += encoding->minBytesPerChar;
2489     entityTextEnd -= encoding->minBytesPerChar;
2490     for (;;) {
2491         const char *next;
2492         int tok = XmlEntityValueTok(encoding, entityTextPtr, entityTextEnd, &next);
2493         switch (tok) {
2494         case XML_TOK_PARAM_ENTITY_REF:
2495             eventPtr = entityTextPtr;
2496             return XML_ERROR_SYNTAX;
2497         case XML_TOK_NONE:
2498             if (declEntity) {
2499                 declEntity->textPtr = pool->start;
2500                 declEntity->textLen = pool->ptr - pool->start;
2501                 poolFinish(pool);
2502             }
2503             else
2504                 poolDiscard(pool);
2505             return XML_ERROR_NONE;
2506         case XML_TOK_ENTITY_REF:
2507         case XML_TOK_DATA_CHARS:
2508             if (!poolAppend(pool, encoding, entityTextPtr, next))
2509                 return XML_ERROR_NO_MEMORY;
2510             break;
2511         case XML_TOK_TRAILING_CR:
2512             next = entityTextPtr + encoding->minBytesPerChar;
2513             /* fall through */
2514         case XML_TOK_DATA_NEWLINE:
2515             if (pool->end == pool->ptr && !poolGrow(pool))
2516                 return XML_ERROR_NO_MEMORY;
2517             *(pool->ptr)++ = 0xA;
2518             break;
2519         case XML_TOK_CHAR_REF:
2520             {
2521                 XML_Char buf[XML_ENCODE_MAX];
2522                 int i;
2523                 int n = XmlCharRefNumber(encoding, entityTextPtr);
2524                 if (n < 0) {
2525                     eventPtr = entityTextPtr;
2526                     return XML_ERROR_BAD_CHAR_REF;
2527                 }
2528                 n = XmlEncode(n, (ICHAR *)buf);
2529                 if (!n) {
2530                     eventPtr = entityTextPtr;
2531                     return XML_ERROR_BAD_CHAR_REF;
2532                 }
2533                 for (i = 0; i < n; i++) {
2534                     if (pool->end == pool->ptr && !poolGrow(pool))
2535                         return XML_ERROR_NO_MEMORY;
2536                     *(pool->ptr)++ = buf[i];
2537                 }
2538             }
2539             break;
2540         case XML_TOK_PARTIAL:
2541             eventPtr = entityTextPtr;
2542             return XML_ERROR_INVALID_TOKEN;
2543         case XML_TOK_INVALID:
2544             eventPtr = next;
2545             return XML_ERROR_INVALID_TOKEN;
2546         default:
2547             abort();
2548         }
2549         entityTextPtr = next;
2550     }
2551     /* not reached */
2552 }
2553
2554 static void
2555 normalizeLines(XML_Char *s)
2556 {
2557     XML_Char *p;
2558     for (;; s++) {
2559         if (*s == XML_T('\0'))
2560             return;
2561         if (*s == 0xD)
2562             break;
2563     }
2564     p = s;
2565     do {
2566         if (*s == 0xD) {
2567             *p++ = 0xA;
2568             if (*++s == 0xA)
2569                 s++;
2570         }
2571         else
2572             *p++ = *s++;
2573     } while (*s);
2574     *p = XML_T('\0');
2575 }
2576
2577 static int
2578 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
2579 {
2580     const XML_Char *target;
2581     XML_Char *data;
2582     const char *tem;
2583     if (!processingInstructionHandler) {
2584         if (defaultHandler)
2585             reportDefault(parser, enc, start, end);
2586         return 1;
2587     }
2588     start += enc->minBytesPerChar * 2;
2589     tem = start + XmlNameLength(enc, start);
2590     target = poolStoreString(&tempPool, enc, start, tem);
2591     if (!target)
2592         return 0;
2593     poolFinish(&tempPool);
2594     data = poolStoreString(&tempPool, enc,
2595                            XmlSkipS(enc, tem),
2596                            end - enc->minBytesPerChar*2);
2597     if (!data)
2598         return 0;
2599     normalizeLines(data);
2600     processingInstructionHandler(handlerArg, target, data);
2601     poolClear(&tempPool);
2602     return 1;
2603 }
2604
2605 static int
2606 reportComment(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
2607 {
2608     XML_Char *data;
2609     if (!commentHandler) {
2610         if (defaultHandler)
2611             reportDefault(parser, enc, start, end);
2612         return 1;
2613     }
2614     data = poolStoreString(&tempPool,
2615                            enc,
2616                            start + enc->minBytesPerChar * 4,
2617                            end - enc->minBytesPerChar * 3);
2618     if (!data)
2619         return 0;
2620     normalizeLines(data);
2621     commentHandler(handlerArg, data);
2622     poolClear(&tempPool);
2623     return 1;
2624 }
2625
2626 static void
2627 reportDefault(XML_Parser parser, const ENCODING *enc, const char *s, const char *end)
2628 {
2629     if (MUST_CONVERT(enc, s)) {
2630         const char **eventPP;
2631         const char **eventEndPP;
2632         if (enc == encoding) {
2633             eventPP = &eventPtr;
2634             eventEndPP = &eventEndPtr;
2635         }
2636         else {
2637             eventPP = &(openInternalEntities->internalEventPtr);
2638             eventEndPP = &(openInternalEntities->internalEventEndPtr);
2639         }
2640         do {
2641             ICHAR *dataPtr = (ICHAR *)dataBuf;
2642             XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
2643             *eventEndPP = s;
2644             defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);
2645             *eventPP = s;
2646         } while (s != end);
2647     }
2648     else
2649         defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s);
2650 }
2651
2652
2653 static int
2654 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, int isCdata, const XML_Char *value)
2655 {
2656     DEFAULT_ATTRIBUTE *att;
2657     if (type->nDefaultAtts == type->allocDefaultAtts) {
2658         if (type->allocDefaultAtts == 0) {
2659             type->allocDefaultAtts = 8;
2660             type->defaultAtts = malloc(type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
2661         }
2662         else {
2663             type->allocDefaultAtts *= 2;
2664             type->defaultAtts = realloc(type->defaultAtts,
2665                                         type->allocDefaultAtts*sizeof(DEFAULT_ATTRIBUTE));
2666         }
2667         if (!type->defaultAtts)
2668             return 0;
2669     }
2670     att = type->defaultAtts + type->nDefaultAtts;
2671     att->id = attId;
2672     att->value = value;
2673     att->isCdata = isCdata;
2674     if (!isCdata)
2675         attId->maybeTokenized = 1;
2676     type->nDefaultAtts += 1;
2677     return 1;
2678 }
2679
2680 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType)
2681 {
2682     const XML_Char *name;
2683     for (name = elementType->name; *name; name++) {
2684         if (*name == XML_T(':')) {
2685             PREFIX *prefix;
2686             const XML_Char *s;
2687             for (s = elementType->name; s != name; s++) {
2688                 if (!poolAppendChar(&dtd.pool, *s))
2689                     return 0;
2690             }
2691             if (!poolAppendChar(&dtd.pool, XML_T('\0')))
2692                 return 0;
2693             prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
2694             if (!prefix)
2695                 return 0;
2696             if (prefix->name == poolStart(&dtd.pool))
2697                 poolFinish(&dtd.pool);
2698             else
2699                 poolDiscard(&dtd.pool);
2700             elementType->prefix = prefix;
2701
2702         }
2703     }
2704     return 1;
2705 }
2706
2707 static ATTRIBUTE_ID *
2708 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start, const char *end)
2709 {
2710     ATTRIBUTE_ID *id;
2711     const XML_Char *name;
2712     if (!poolAppendChar(&dtd.pool, XML_T('\0')))
2713         return 0;
2714     name = poolStoreString(&dtd.pool, enc, start, end);
2715     if (!name)
2716         return 0;
2717     ++name;
2718     id = (ATTRIBUTE_ID *)lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID));
2719     if (!id)
2720         return 0;
2721     if (id->name != name)
2722         poolDiscard(&dtd.pool);
2723     else {
2724         poolFinish(&dtd.pool);
2725         if (!ns)
2726             ;
2727         else if (name[0] == 'x'
2728                  && name[1] == 'm'
2729                  && name[2] == 'l'
2730                  && name[3] == 'n'
2731                  && name[4] == 's'
2732                  && (name[5] == XML_T('\0') || name[5] == XML_T(':'))) {
2733             if (name[5] == '\0')
2734                 id->prefix = &dtd.defaultPrefix;
2735             else
2736                 id->prefix = (PREFIX *)lookup(&dtd.prefixes, name + 6, sizeof(PREFIX));
2737             id->xmlns = 1;
2738         }
2739         else {
2740             int i;
2741             for (i = 0; name[i]; i++) {
2742                 if (name[i] == XML_T(':')) {
2743                     int j;
2744                     for (j = 0; j < i; j++) {
2745                         if (!poolAppendChar(&dtd.pool, name[j]))
2746                             return 0;
2747                     }
2748                     if (!poolAppendChar(&dtd.pool, XML_T('\0')))
2749                         return 0;
2750                     id->prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
2751                     if (id->prefix->name == poolStart(&dtd.pool))
2752                         poolFinish(&dtd.pool);
2753                     else
2754                         poolDiscard(&dtd.pool);
2755                     break;
2756                 }
2757             }
2758         }
2759     }
2760     return id;
2761 }
2762
2763 #define CONTEXT_SEP XML_T('\f')
2764
2765 static
2766 const XML_Char *getContext(XML_Parser parser)
2767 {
2768     HASH_TABLE_ITER iter;
2769     int needSep = 0;
2770
2771     if (dtd.defaultPrefix.binding) {
2772         int i;
2773         int len;
2774         if (!poolAppendChar(&tempPool, XML_T('=')))
2775             return 0;
2776         len = dtd.defaultPrefix.binding->uriLen;
2777         if (namespaceSeparator != XML_T('\0'))
2778             len--;
2779         for (i = 0; i < len; i++)
2780             if (!poolAppendChar(&tempPool, dtd.defaultPrefix.binding->uri[i]))
2781                 return 0;
2782         needSep = 1;
2783     }
2784
2785     hashTableIterInit(&iter, &(dtd.prefixes));
2786     for (;;) {
2787         int i;
2788         int len;
2789         const XML_Char *s;
2790         PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
2791         if (!prefix)
2792             break;
2793         if (!prefix->binding)
2794             continue;
2795         if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
2796             return 0;
2797         for (s = prefix->name; *s; s++)
2798             if (!poolAppendChar(&tempPool, *s))
2799                 return 0;
2800         if (!poolAppendChar(&tempPool, XML_T('=')))
2801             return 0;
2802         len = prefix->binding->uriLen;
2803         if (namespaceSeparator != XML_T('\0'))
2804             len--;
2805         for (i = 0; i < len; i++)
2806             if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
2807                 return 0;
2808         needSep = 1;
2809     }
2810
2811
2812     hashTableIterInit(&iter, &(dtd.generalEntities));
2813     for (;;) {
2814         const XML_Char *s;
2815         ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
2816         if (!e)
2817             break;
2818         if (!e->open)
2819             continue;
2820         if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
2821             return 0;
2822         for (s = e->name; *s; s++)
2823             if (!poolAppendChar(&tempPool, *s))
2824                 return 0;
2825         needSep = 1;
2826     }
2827
2828     if (!poolAppendChar(&tempPool, XML_T('\0')))
2829         return 0;
2830     return tempPool.start;
2831 }
2832
2833 static
2834 int setContext(XML_Parser parser, const XML_Char *context)
2835 {
2836     const XML_Char *s = context;
2837
2838     while (*context != XML_T('\0')) {
2839         if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
2840             ENTITY *e;
2841             if (!poolAppendChar(&tempPool, XML_T('\0')))
2842                 return 0;
2843             e = (ENTITY *)lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
2844             if (e)
2845                 e->open = 1;
2846             if (*s != XML_T('\0'))
2847                 s++;
2848             context = s;
2849             poolDiscard(&tempPool);
2850         }
2851         else if (*s == '=') {
2852             PREFIX *prefix;
2853             if (poolLength(&tempPool) == 0)
2854                 prefix = &dtd.defaultPrefix;
2855             else {
2856                 if (!poolAppendChar(&tempPool, XML_T('\0')))
2857                     return 0;
2858                 prefix = (PREFIX *)lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX));
2859                 if (!prefix)
2860                     return 0;
2861                 if (prefix->name == poolStart(&tempPool))
2862                     poolFinish(&tempPool);
2863                 else
2864                     poolDiscard(&tempPool);
2865             }
2866             for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0'); context++)
2867                 if (!poolAppendChar(&tempPool, *context))
2868                     return 0;
2869             if (!poolAppendChar(&tempPool, XML_T('\0')))
2870                 return 0;
2871             if (!addBinding(parser, prefix, 0, poolStart(&tempPool), &inheritedBindings))
2872                 return 0;
2873             poolDiscard(&tempPool);
2874             if (*context != XML_T('\0'))
2875                 ++context;
2876             s = context;
2877         }
2878         else {
2879             if (!poolAppendChar(&tempPool, *s))
2880                 return 0;
2881             s++;
2882         }
2883     }
2884     return 1;
2885 }
2886
2887
2888 static
2889 void normalizePublicId(XML_Char *publicId)
2890 {
2891     XML_Char *p = publicId;
2892     XML_Char *s;
2893     for (s = publicId; *s; s++) {
2894         switch (*s) {
2895         case 0x20:
2896         case 0xD:
2897         case 0xA:
2898             if (p != publicId && p[-1] != 0x20)
2899                 *p++ = 0x20;
2900             break;
2901         default:
2902             *p++ = *s;
2903         }
2904     }
2905     if (p != publicId && p[-1] == 0x20)
2906         --p;
2907     *p = XML_T('\0');
2908 }
2909
2910 static int dtdInit(DTD *p)
2911 {
2912     poolInit(&(p->pool));
2913     hashTableInit(&(p->generalEntities));
2914     hashTableInit(&(p->elementTypes));
2915     hashTableInit(&(p->attributeIds));
2916     hashTableInit(&(p->prefixes));
2917     p->complete = 1;
2918     p->standalone = 0;
2919     p->base = 0;
2920     p->defaultPrefix.name = 0;
2921     p->defaultPrefix.binding = 0;
2922     return 1;
2923 }
2924
2925 static void dtdDestroy(DTD *p)
2926 {
2927     HASH_TABLE_ITER iter;
2928     hashTableIterInit(&iter, &(p->elementTypes));
2929     for (;;) {
2930         ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
2931         if (!e)
2932             break;
2933         if (e->allocDefaultAtts != 0)
2934             free(e->defaultAtts);
2935     }
2936     hashTableDestroy(&(p->generalEntities));
2937     hashTableDestroy(&(p->elementTypes));
2938     hashTableDestroy(&(p->attributeIds));
2939     hashTableDestroy(&(p->prefixes));
2940     poolDestroy(&(p->pool));
2941 }
2942
2943 /* Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
2944 The new DTD has already been initialized. */
2945
2946 static int dtdCopy(DTD *newDtd, const DTD *oldDtd)
2947 {
2948     HASH_TABLE_ITER iter;
2949
2950     if (oldDtd->base) {
2951         const XML_Char *tem = poolCopyString(&(newDtd->pool), oldDtd->base);
2952         if (!tem)
2953             return 0;
2954         newDtd->base = tem;
2955     }
2956
2957     /* Copy the prefix table. */
2958
2959     hashTableIterInit(&iter, &(oldDtd->prefixes));
2960     for (;;) {
2961         const XML_Char *name;
2962         const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
2963         if (!oldP)
2964             break;
2965         name = poolCopyString(&(newDtd->pool), oldP->name);
2966         if (!name)
2967             return 0;
2968         if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))
2969             return 0;
2970     }
2971
2972     hashTableIterInit(&iter, &(oldDtd->attributeIds));
2973
2974     /* Copy the attribute id table. */
2975
2976     for (;;) {
2977         ATTRIBUTE_ID *newA;
2978         const XML_Char *name;
2979         const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
2980
2981         if (!oldA)
2982             break;
2983         /* Remember to allocate the scratch byte before the name. */
2984         if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
2985             return 0;
2986         name = poolCopyString(&(newDtd->pool), oldA->name);
2987         if (!name)
2988             return 0;
2989         ++name;
2990         newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
2991         if (!newA)
2992             return 0;
2993         newA->maybeTokenized = oldA->maybeTokenized;
2994         if (oldA->prefix) {
2995             newA->xmlns = oldA->xmlns;
2996             if (oldA->prefix == &oldDtd->defaultPrefix)
2997                 newA->prefix = &newDtd->defaultPrefix;
2998             else
2999                 newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldA->prefix->name, 0);
3000         }
3001     }
3002
3003     /* Copy the element type table. */
3004
3005     hashTableIterInit(&iter, &(oldDtd->elementTypes));
3006
3007     for (;;) {
3008         int i;
3009         ELEMENT_TYPE *newE;
3010         const XML_Char *name;
3011         const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
3012         if (!oldE)
3013             break;
3014         name = poolCopyString(&(newDtd->pool), oldE->name);
3015         if (!name)
3016             return 0;
3017         newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
3018         if (!newE)
3019             return 0;
3020         if (oldE->nDefaultAtts) {
3021             newE->defaultAtts = (DEFAULT_ATTRIBUTE *)malloc(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
3022             if (!newE->defaultAtts)
3023                 return 0;
3024         }
3025         newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
3026         if (oldE->prefix)
3027             newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes), oldE->prefix->name, 0);
3028         for (i = 0; i < newE->nDefaultAtts; i++) {
3029             newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
3030             newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
3031             if (oldE->defaultAtts[i].value) {
3032                 newE->defaultAtts[i].value = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
3033                 if (!newE->defaultAtts[i].value)
3034                     return 0;
3035             }
3036             else
3037                 newE->defaultAtts[i].value = 0;
3038         }
3039     }
3040
3041     /* Copy the entity table. */
3042
3043     hashTableIterInit(&iter, &(oldDtd->generalEntities));
3044
3045     for (;;) {
3046         ENTITY *newE;
3047         const XML_Char *name;
3048         const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
3049         if (!oldE)
3050             break;
3051         name = poolCopyString(&(newDtd->pool), oldE->name);
3052         if (!name)
3053             return 0;
3054         newE = (ENTITY *)lookup(&(newDtd->generalEntities), name, sizeof(ENTITY));
3055         if (!newE)
3056             return 0;
3057         if (oldE->systemId) {
3058             const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->systemId);
3059             if (!tem)
3060                 return 0;
3061             newE->systemId = tem;
3062             if (oldE->base) {
3063                 if (oldE->base == oldDtd->base)
3064                     newE->base = newDtd->base;
3065                 tem = poolCopyString(&(newDtd->pool), oldE->base);
3066                 if (!tem)
3067                     return 0;
3068                 newE->base = tem;
3069             }
3070         }
3071         else {
3072             const XML_Char *tem = poolCopyStringN(&(newDtd->pool), oldE->textPtr, oldE->textLen);
3073             if (!tem)
3074                 return 0;
3075             newE->textPtr = tem;
3076             newE->textLen = oldE->textLen;
3077         }
3078         if (oldE->notation) {
3079             const XML_Char *tem = poolCopyString(&(newDtd->pool), oldE->notation);
3080             if (!tem)
3081                 return 0;
3082             newE->notation = tem;
3083         }
3084     }
3085
3086     newDtd->complete = oldDtd->complete;
3087     newDtd->standalone = oldDtd->standalone;
3088     return 1;
3089 }
3090
3091 static
3092 void poolInit(STRING_POOL *pool)
3093 {
3094     pool->blocks = 0;
3095     pool->freeBlocks = 0;
3096     pool->start = 0;
3097     pool->ptr = 0;
3098     pool->end = 0;
3099 }
3100
3101 static
3102 void poolClear(STRING_POOL *pool)
3103 {
3104     if (!pool->freeBlocks)
3105         pool->freeBlocks = pool->blocks;
3106     else {
3107         BLOCK *p = pool->blocks;
3108         while (p) {
3109             BLOCK *tem = p->next;
3110             p->next = pool->freeBlocks;
3111             pool->freeBlocks = p;
3112             p = tem;
3113         }
3114     }
3115     pool->blocks = 0;
3116     pool->start = 0;
3117     pool->ptr = 0;
3118     pool->end = 0;
3119 }
3120
3121 static
3122 void poolDestroy(STRING_POOL *pool)
3123 {
3124     BLOCK *p = pool->blocks;
3125     while (p) {
3126         BLOCK *tem = p->next;
3127         free(p);
3128         p = tem;
3129     }
3130     pool->blocks = 0;
3131     p = pool->freeBlocks;
3132     while (p) {
3133         BLOCK *tem = p->next;
3134         free(p);
3135         p = tem;
3136     }
3137     pool->freeBlocks = 0;
3138     pool->ptr = 0;
3139     pool->start = 0;
3140     pool->end = 0;
3141 }
3142
3143 static
3144 XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
3145                      const char *ptr, const char *end)
3146 {
3147     if (!pool->ptr && !poolGrow(pool))
3148         return 0;
3149     for (;;) {
3150         XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
3151         if (ptr == end)
3152             break;
3153         if (!poolGrow(pool))
3154             return 0;
3155     }
3156     return pool->start;
3157 }
3158
3159 static const XML_Char *poolCopyString(STRING_POOL *pool, const XML_Char *s)
3160 {
3161     do {
3162         if (!poolAppendChar(pool, *s))
3163             return 0;
3164     } while (*s++);
3165     s = pool->start;
3166     poolFinish(pool);
3167     return s;
3168 }
3169
3170 static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n)
3171 {
3172     if (!pool->ptr && !poolGrow(pool))
3173         return 0;
3174     for (; n > 0; --n, s++) {
3175         if (!poolAppendChar(pool, *s))
3176             return 0;
3177
3178     }
3179     s = pool->start;
3180     poolFinish(pool);
3181     return s;
3182 }
3183
3184 static
3185 XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
3186                           const char *ptr, const char *end)
3187 {
3188     if (!poolAppend(pool, enc, ptr, end))
3189         return 0;
3190     if (pool->ptr == pool->end && !poolGrow(pool))
3191         return 0;
3192     *(pool->ptr)++ = 0;
3193     return pool->start;
3194 }
3195
3196 static
3197 int poolGrow(STRING_POOL *pool)
3198 {
3199     if (pool->freeBlocks) {
3200         if (pool->start == 0) {
3201             pool->blocks = pool->freeBlocks;
3202             pool->freeBlocks = pool->freeBlocks->next;
3203             pool->blocks->next = 0;
3204             pool->start = pool->blocks->s;
3205             pool->end = pool->start + pool->blocks->size;
3206             pool->ptr = pool->start;
3207             return 1;
3208         }
3209         if (pool->end - pool->start < pool->freeBlocks->size) {
3210             BLOCK *tem = pool->freeBlocks->next;
3211             pool->freeBlocks->next = pool->blocks;
3212             pool->blocks = pool->freeBlocks;
3213             pool->freeBlocks = tem;
3214             memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char));
3215             pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
3216             pool->start = pool->blocks->s;
3217             pool->end = pool->start + pool->blocks->size;
3218             return 1;
3219         }
3220     }
3221     if (pool->blocks && pool->start == pool->blocks->s) {
3222         int blockSize = (pool->end - pool->start)*2;
3223         pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
3224         if (!pool->blocks)
3225             return 0;
3226         pool->blocks->size = blockSize;
3227         pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
3228         pool->start = pool->blocks->s;
3229         pool->end = pool->start + blockSize;
3230     }
3231     else {
3232         BLOCK *tem;
3233         int blockSize = pool->end - pool->start;
3234         if (blockSize < INIT_BLOCK_SIZE)
3235             blockSize = INIT_BLOCK_SIZE;
3236         else
3237             blockSize *= 2;
3238         tem = malloc(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
3239         if (!tem)
3240             return 0;
3241         tem->size = blockSize;
3242         tem->next = pool->blocks;
3243         pool->blocks = tem;
3244         memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
3245         pool->ptr = tem->s + (pool->ptr - pool->start);
3246         pool->start = tem->s;
3247         pool->end = tem->s + blockSize;
3248     }
3249     return 1;
3250 }