1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd

     2    See the file COPYING for copying permission.

     3 */

     4 

     5 #include <stddef.h>

     6 #include <string.h>                     /* memset(), memcpy() */

     7 #include <assert.h>

     8 

     9 #define XML_BUILDING_EXPAT 1

    10 

    11 #ifdef COMPILED_FROM_DSP

    12 #include "winconfig.h"

    13 #elif defined(MACOS_CLASSIC)

    14 #include "macconfig.h"

    15 #elif defined(__amigaos4__)

    16 #include "amigaconfig.h"

    17 #elif defined(HAVE_EXPAT_CONFIG_H)

    18 #include <expat_config.h>

    19 #endif /* ndef COMPILED_FROM_DSP */

    20 

    21 #include "expat.h"

    22 

    23 #ifdef XML_UNICODE

    24 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

    25 #define XmlConvert XmlUtf16Convert

    26 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding

    27 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS

    28 #define XmlEncode XmlUtf16Encode

    29 #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))

    30 typedef unsigned short ICHAR;

    31 #else

    32 #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

    33 #define XmlConvert XmlUtf8Convert

    34 #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

    35 #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

    36 #define XmlEncode XmlUtf8Encode

    37 #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)

    38 typedef char ICHAR;

    39 #endif

    40 

    41 

    42 #ifndef XML_NS

    43 

    44 #define XmlInitEncodingNS XmlInitEncoding

    45 #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

    46 #undef XmlGetInternalEncodingNS

    47 #define XmlGetInternalEncodingNS XmlGetInternalEncoding

    48 #define XmlParseXmlDeclNS XmlParseXmlDecl

    49 

    50 #endif

    51 

    52 #ifdef XML_UNICODE

    53 

    54 #ifdef XML_UNICODE_WCHAR_T

    55 #define XML_T(x) (const wchar_t)x

    56 #define XML_L(x) L ## x

    57 #else

    58 #define XML_T(x) (const unsigned short)x

    59 #define XML_L(x) x

    60 #endif

    61 

    62 #else

    63 

    64 #define XML_T(x) x

    65 #define XML_L(x) x

    66 

    67 #endif

    68 

    69 /* Round up n to be a multiple of sz, where sz is a power of 2. */

    70 #define ROUND_UP(n, sz) (((n) + ((sz) - 1)) & ~((sz) - 1))

    71 

    72 /* Handle the case where memmove() doesn't exist. */

    73 #ifndef HAVE_MEMMOVE

    74 #ifdef HAVE_BCOPY

    75 #define memmove(d,s,l) bcopy((s),(d),(l))

    76 #else

    77 #error memmove does not exist on this platform, nor is a substitute available

    78 #endif /* HAVE_BCOPY */

    79 #endif /* HAVE_MEMMOVE */

    80 

    81 #include "internal.h"

    82 #include "xmltok.h"

    83 #include "xmlrole.h"

    84 

    85 typedef const XML_Char *KEY;

    86 

    87 typedef struct {

    88   KEY name;

    89 } NAMED;

    90 

    91 typedef struct {

    92   NAMED **v;

    93   unsigned char power;

    94   size_t size;

    95   size_t used;

    96   const XML_Memory_Handling_Suite *mem;

    97 } HASH_TABLE;

    98 

    99 /* Basic character hash algorithm, taken from Python's string hash:

   100    h = h * 1000003 ^ character, the constant being a prime number.

   101 

   102 */

   103 #ifdef XML_UNICODE

   104 #define CHAR_HASH(h, c) \

   105   (((h) * 0xF4243) ^ (unsigned short)(c))

   106 #else

   107 #define CHAR_HASH(h, c) \

   108   (((h) * 0xF4243) ^ (unsigned char)(c))

   109 #endif

   110 

   111 /* For probing (after a collision) we need a step size relative prime

   112    to the hash table size, which is a power of 2. We use double-hashing,

   113    since we can calculate a second hash value cheaply by taking those bits

   114    of the first hash value that were discarded (masked out) when the table

   115    index was calculated: index = hash & mask, where mask = table->size - 1.

   116    We limit the maximum step size to table->size / 4 (mask >> 2) and make

   117    it odd, since odd numbers are always relative prime to a power of 2.

   118 */

   119 #define SECOND_HASH(hash, mask, power) \

   120   ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

   121 #define PROBE_STEP(hash, mask, power) \

   122   ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))

   123 

   124 typedef struct {

   125   NAMED **p;

   126   NAMED **end;

   127 } HASH_TABLE_ITER;

   128 

   129 #define INIT_TAG_BUF_SIZE 32  /* must be a multiple of sizeof(XML_Char) */

   130 #define INIT_DATA_BUF_SIZE 1024

   131 #define INIT_ATTS_SIZE 16

   132 #define INIT_ATTS_VERSION 0xFFFFFFFF

   133 #define INIT_BLOCK_SIZE 1024

   134 #define INIT_BUFFER_SIZE 1024

   135 

   136 #define EXPAND_SPARE 24

   137 

   138 typedef struct binding {

   139   struct prefix *prefix;

   140   struct binding *nextTagBinding;

   141   struct binding *prevPrefixBinding;

   142   const struct attribute_id *attId;

   143   XML_Char *uri;

   144   int uriLen;

   145   int uriAlloc;

   146 } BINDING;

   147 

   148 typedef struct prefix {

   149   const XML_Char *name;

   150   BINDING *binding;

   151 } PREFIX;

   152 

   153 typedef struct {

   154   const XML_Char *str;

   155   const XML_Char *localPart;

   156   const XML_Char *prefix;

   157   int strLen;

   158   int uriLen;

   159   int prefixLen;

   160 } TAG_NAME;

   161 

   162 /* TAG represents an open element.

   163    The name of the element is stored in both the document and API

   164    encodings.  The memory buffer 'buf' is a separately-allocated

   165    memory area which stores the name.  During the XML_Parse()/

   166    XMLParseBuffer() when the element is open, the memory for the 'raw'

   167    version of the name (in the document encoding) is shared with the

   168    document buffer.  If the element is open across calls to

   169    XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to

   170    contain the 'raw' name as well.

   171 

   172    A parser re-uses these structures, maintaining a list of allocated

   173    TAG objects in a free list.

   174 */

   175 typedef struct tag {

   176   struct tag *parent;           /* parent of this element */

   177   const char *rawName;          /* tagName in the original encoding */

   178   int rawNameLength;

   179   TAG_NAME name;                /* tagName in the API encoding */

   180   char *buf;                    /* buffer for name components */

   181   char *bufEnd;                 /* end of the buffer */

   182   BINDING *bindings;

   183 } TAG;

   184 

   185 typedef struct {

   186   const XML_Char *name;

   187   const XML_Char *textPtr;

   188   int textLen;                  /* length in XML_Chars */

   189   int processed;                /* # of processed bytes - when suspended */

   190   const XML_Char *systemId;

   191   const XML_Char *base;

   192   const XML_Char *publicId;

   193   const XML_Char *notation;

   194   XML_Bool open;

   195   XML_Bool is_param;

   196   XML_Bool is_internal; /* true if declared in internal subset outside PE */

   197 } ENTITY;

   198 

   199 typedef struct {

   200   enum XML_Content_Type         type;

   201   enum XML_Content_Quant        quant;

   202   const XML_Char *              name;

   203   int                           firstchild;

   204   int                           lastchild;

   205   int                           childcnt;

   206   int                           nextsib;

   207 } CONTENT_SCAFFOLD;

   208 

   209 #define INIT_SCAFFOLD_ELEMENTS 32

   210 

   211 typedef struct block {

   212   struct block *next;

   213   int size;

   214   XML_Char s[1];

   215 } BLOCK;

   216 

   217 typedef struct {

   218   BLOCK *blocks;

   219   BLOCK *freeBlocks;

   220   const XML_Char *end;

   221   XML_Char *ptr;

   222   XML_Char *start;

   223   const XML_Memory_Handling_Suite *mem;

   224 } STRING_POOL;

   225 

   226 /* The XML_Char before the name is used to determine whether

   227    an attribute has been specified. */

   228 typedef struct attribute_id {

   229   XML_Char *name;

   230   PREFIX *prefix;

   231   XML_Bool maybeTokenized;

   232   XML_Bool xmlns;

   233 } ATTRIBUTE_ID;

   234 

   235 typedef struct {

   236   const ATTRIBUTE_ID *id;

   237   XML_Bool isCdata;

   238   const XML_Char *value;

   239 } DEFAULT_ATTRIBUTE;

   240 

   241 typedef struct {

   242   unsigned long version;

   243   unsigned long hash;

   244   const XML_Char *uriName;

   245 } NS_ATT;

   246 

   247 typedef struct {

   248   const XML_Char *name;

   249   PREFIX *prefix;

   250   const ATTRIBUTE_ID *idAtt;

   251   int nDefaultAtts;

   252   int allocDefaultAtts;

   253   DEFAULT_ATTRIBUTE *defaultAtts;

   254 } ELEMENT_TYPE;

   255 

   256 typedef struct {

   257   HASH_TABLE generalEntities;

   258   HASH_TABLE elementTypes;

   259   HASH_TABLE attributeIds;

   260   HASH_TABLE prefixes;

   261   STRING_POOL pool;

   262   STRING_POOL entityValuePool;

   263   /* false once a parameter entity reference has been skipped */

   264   XML_Bool keepProcessing;

   265   /* true once an internal or external PE reference has been encountered;

   266      this includes the reference to an external subset */

   267   XML_Bool hasParamEntityRefs;

   268   XML_Bool standalone;

   269 #ifdef XML_DTD

   270   /* indicates if external PE has been read */

   271   XML_Bool paramEntityRead;

   272   HASH_TABLE paramEntities;

   273 #endif /* XML_DTD */

   274   PREFIX defaultPrefix;

   275   /* === scaffolding for building content model === */

   276   XML_Bool in_eldecl;

   277   CONTENT_SCAFFOLD *scaffold;

   278   unsigned contentStringLen;

   279   unsigned scaffSize;

   280   unsigned scaffCount;

   281   int scaffLevel;

   282   int *scaffIndex;

   283 } DTD;

   284 

   285 typedef struct open_internal_entity {

   286   const char *internalEventPtr;

   287   const char *internalEventEndPtr;

   288   struct open_internal_entity *next;

   289   ENTITY *entity;

   290   int startTagLevel;

   291   XML_Bool betweenDecl; /* WFC: PE Between Declarations */

   292 } OPEN_INTERNAL_ENTITY;

   293 

   294 typedef enum XML_Error PTRCALL Processor(XML_Parser parser,

   295                                          const char *start,

   296                                          const char *end,

   297                                          const char **endPtr);

   298 

   299 static Processor prologProcessor;

   300 static Processor prologInitProcessor;

   301 static Processor contentProcessor;

   302 static Processor cdataSectionProcessor;

   303 #ifdef XML_DTD

   304 static Processor ignoreSectionProcessor;

   305 static Processor externalParEntProcessor;

   306 static Processor externalParEntInitProcessor;

   307 static Processor entityValueProcessor;

   308 static Processor entityValueInitProcessor;

   309 #endif /* XML_DTD */

   310 static Processor epilogProcessor;

   311 static Processor errorProcessor;

   312 static Processor externalEntityInitProcessor;

   313 static Processor externalEntityInitProcessor2;

   314 static Processor externalEntityInitProcessor3;

   315 static Processor externalEntityContentProcessor;

   316 static Processor internalEntityProcessor;

   317 

   318 static enum XML_Error

   319 handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);

   320 static enum XML_Error

   321 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

   322                const char *s, const char *next);

   323 static enum XML_Error

   324 initializeEncoding(XML_Parser parser);

   325 static enum XML_Error

   326 doProlog(XML_Parser parser, const ENCODING *enc, const char *s, 

   327          const char *end, int tok, const char *next, const char **nextPtr, 

   328          XML_Bool haveMore);

   329 static enum XML_Error

   330 processInternalEntity(XML_Parser parser, ENTITY *entity, 

   331                       XML_Bool betweenDecl);

   332 static enum XML_Error

   333 doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,

   334           const char *start, const char *end, const char **endPtr, 

   335           XML_Bool haveMore);

   336 static enum XML_Error

   337 doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,

   338                const char *end, const char **nextPtr, XML_Bool haveMore);

   339 #ifdef XML_DTD

   340 static enum XML_Error

   341 doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,

   342                 const char *end, const char **nextPtr, XML_Bool haveMore);

   343 #endif /* XML_DTD */

   344 

   345 static enum XML_Error

   346 storeAtts(XML_Parser parser, const ENCODING *, const char *s,

   347           TAG_NAME *tagNamePtr, BINDING **bindingsPtr);

   348 static enum XML_Error

   349 addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

   350            const XML_Char *uri, BINDING **bindingsPtr);

   351 static int

   352 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata, 

   353                 XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);

   354 static enum XML_Error

   355 storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,

   356                     const char *, const char *, STRING_POOL *);

   357 static enum XML_Error

   358 appendAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,

   359                      const char *, const char *, STRING_POOL *);

   360 static ATTRIBUTE_ID *

   361 getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,

   362                const char *end);

   363 static int

   364 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);

   365 static enum XML_Error

   366 storeEntityValue(XML_Parser parser, const ENCODING *enc, const char *start,

   367                  const char *end);

   368 static int

   369 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

   370                             const char *start, const char *end);

   371 static int

   372 reportComment(XML_Parser parser, const ENCODING *enc, const char *start,

   373               const char *end);

   374 static void

   375 reportDefault(XML_Parser parser, const ENCODING *enc, const char *start,

   376               const char *end);

   377 

   378 static const XML_Char * getContext(XML_Parser parser);

   379 static XML_Bool

   380 setContext(XML_Parser parser, const XML_Char *context);

   381 

   382 static void FASTCALL normalizePublicId(XML_Char *s);

   383 

   384 static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);

   385 /* do not call if parentParser != NULL */

   386 static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);

   387 static void

   388 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms);

   389 static int

   390 dtdCopy(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);

   391 static int

   392 copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);

   393 

   394 static NAMED *

   395 lookup(HASH_TABLE *table, KEY name, size_t createSize);

   396 static void FASTCALL

   397 hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);

   398 static void FASTCALL hashTableClear(HASH_TABLE *);

   399 static void FASTCALL hashTableDestroy(HASH_TABLE *);

   400 static void FASTCALL

   401 hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);

   402 static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);

   403 

   404 static void FASTCALL

   405 poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);

   406 static void FASTCALL poolClear(STRING_POOL *);

   407 static void FASTCALL poolDestroy(STRING_POOL *);

   408 static XML_Char *

   409 poolAppend(STRING_POOL *pool, const ENCODING *enc,

   410            const char *ptr, const char *end);

   411 static XML_Char *

   412 poolStoreString(STRING_POOL *pool, const ENCODING *enc,

   413                 const char *ptr, const char *end);

   414 static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);

   415 static const XML_Char * FASTCALL

   416 poolCopyString(STRING_POOL *pool, const XML_Char *s);

   417 static const XML_Char *

   418 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n);

   419 static const XML_Char * FASTCALL

   420 poolAppendString(STRING_POOL *pool, const XML_Char *s);

   421 

   422 static int FASTCALL nextScaffoldPart(XML_Parser parser);

   423 static XML_Content * build_model(XML_Parser parser);

   424 static ELEMENT_TYPE *

   425 getElementType(XML_Parser parser, const ENCODING *enc,

   426                const char *ptr, const char *end);

   427 

   428 static XML_Parser

   429 parserCreate(const XML_Char *encodingName,

   430              const XML_Memory_Handling_Suite *memsuite,

   431              const XML_Char *nameSep,

   432              DTD *dtd);

   433 static void

   434 parserInit(XML_Parser parser, const XML_Char *encodingName);

   435 

   436 #define poolStart(pool) ((pool)->start)

   437 #define poolEnd(pool) ((pool)->ptr)

   438 #define poolLength(pool) ((pool)->ptr - (pool)->start)

   439 #define poolChop(pool) ((void)--(pool->ptr))

   440 #define poolLastChar(pool) (((pool)->ptr)[-1])

   441 #define poolDiscard(pool) ((pool)->ptr = (pool)->start)

   442 #define poolFinish(pool) ((pool)->start = (pool)->ptr)

   443 #define poolAppendChar(pool, c) \

   444   (((pool)->ptr == (pool)->end && !poolGrow(pool)) \

   445    ? 0 \

   446    : ((*((pool)->ptr)++ = c), 1))

   447 

   448 struct XML_ParserStruct {

   449   /* The first member must be userData so that the XML_GetUserData

   450      macro works. */

   451   void *m_userData;

   452   void *m_handlerArg;

   453   char *m_buffer;

   454   const XML_Memory_Handling_Suite m_mem;

   455   /* first character to be parsed */

   456   const char *m_bufferPtr;

   457   /* past last character to be parsed */

   458   char *m_bufferEnd;

   459   /* allocated end of buffer */

   460   const char *m_bufferLim;

   461   XML_Index m_parseEndByteIndex;

   462   const char *m_parseEndPtr;

   463   XML_Char *m_dataBuf;

   464   XML_Char *m_dataBufEnd;

   465   XML_StartElementHandler m_startElementHandler;

   466   XML_EndElementHandler m_endElementHandler;

   467   XML_CharacterDataHandler m_characterDataHandler;

   468   XML_ProcessingInstructionHandler m_processingInstructionHandler;

   469   XML_CommentHandler m_commentHandler;

   470   XML_StartCdataSectionHandler m_startCdataSectionHandler;

   471   XML_EndCdataSectionHandler m_endCdataSectionHandler;

   472   XML_DefaultHandler m_defaultHandler;

   473   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;

   474   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;

   475   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;

   476   XML_NotationDeclHandler m_notationDeclHandler;

   477   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;

   478   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;

   479   XML_NotStandaloneHandler m_notStandaloneHandler;

   480   XML_ExternalEntityRefHandler m_externalEntityRefHandler;

   481   XML_Parser m_externalEntityRefHandlerArg;

   482   XML_SkippedEntityHandler m_skippedEntityHandler;

   483   XML_UnknownEncodingHandler m_unknownEncodingHandler;

   484   XML_ElementDeclHandler m_elementDeclHandler;

   485   XML_AttlistDeclHandler m_attlistDeclHandler;

   486   XML_EntityDeclHandler m_entityDeclHandler;

   487   XML_XmlDeclHandler m_xmlDeclHandler;

   488   const ENCODING *m_encoding;

   489   INIT_ENCODING m_initEncoding;

   490   const ENCODING *m_internalEncoding;

   491   const XML_Char *m_protocolEncodingName;

   492   XML_Bool m_ns;

   493   XML_Bool m_ns_triplets;

   494   void *m_unknownEncodingMem;

   495   void *m_unknownEncodingData;

   496   void *m_unknownEncodingHandlerData;

   497   void (XMLCALL *m_unknownEncodingRelease)(void *);

   498   PROLOG_STATE m_prologState;

   499   Processor *m_processor;

   500   enum XML_Error m_errorCode;

   501   const char *m_eventPtr;

   502   const char *m_eventEndPtr;

   503   const char *m_positionPtr;

   504   OPEN_INTERNAL_ENTITY *m_openInternalEntities;

   505   OPEN_INTERNAL_ENTITY *m_freeInternalEntities;

   506   XML_Bool m_defaultExpandInternalEntities;

   507   int m_tagLevel;

   508   ENTITY *m_declEntity;

   509   const XML_Char *m_doctypeName;

   510   const XML_Char *m_doctypeSysid;

   511   const XML_Char *m_doctypePubid;

   512   const XML_Char *m_declAttributeType;

   513   const XML_Char *m_declNotationName;

   514   const XML_Char *m_declNotationPublicId;

   515   ELEMENT_TYPE *m_declElementType;

   516   ATTRIBUTE_ID *m_declAttributeId;

   517   XML_Bool m_declAttributeIsCdata;

   518   XML_Bool m_declAttributeIsId;

   519   DTD *m_dtd;

   520   const XML_Char *m_curBase;

   521   TAG *m_tagStack;

   522   TAG *m_freeTagList;

   523   BINDING *m_inheritedBindings;

   524   BINDING *m_freeBindingList;

   525   int m_attsSize;

   526   int m_nSpecifiedAtts;

   527   int m_idAttIndex;

   528   ATTRIBUTE *m_atts;

   529   NS_ATT *m_nsAtts;

   530   unsigned long m_nsAttsVersion;

   531   unsigned char m_nsAttsPower;

   532   POSITION m_position;

   533   STRING_POOL m_tempPool;

   534   STRING_POOL m_temp2Pool;

   535   char *m_groupConnector;

   536   unsigned int m_groupSize;

   537   XML_Char m_namespaceSeparator;

   538   XML_Parser m_parentParser;

   539   XML_ParsingStatus m_parsingStatus;

   540 #ifdef XML_DTD

   541   XML_Bool m_isParamEntity;

   542   XML_Bool m_useForeignDTD;

   543   enum XML_ParamEntityParsing m_paramEntityParsing;

   544 #endif

   545 };

   546 

   547 #define MALLOC(s) (parser->m_mem.malloc_fcn((s)))

   548 #define REALLOC(p,s) (parser->m_mem.realloc_fcn((p),(s)))

   549 #define FREE(p) (parser->m_mem.free_fcn((p)))

   550 

   551 #define userData (parser->m_userData)

   552 #define handlerArg (parser->m_handlerArg)

   553 #define startElementHandler (parser->m_startElementHandler)

   554 #define endElementHandler (parser->m_endElementHandler)

   555 #define characterDataHandler (parser->m_characterDataHandler)

   556 #define processingInstructionHandler \

   557         (parser->m_processingInstructionHandler)

   558 #define commentHandler (parser->m_commentHandler)

   559 #define startCdataSectionHandler \

   560         (parser->m_startCdataSectionHandler)

   561 #define endCdataSectionHandler (parser->m_endCdataSectionHandler)

   562 #define defaultHandler (parser->m_defaultHandler)

   563 #define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

   564 #define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

   565 #define unparsedEntityDeclHandler \

   566         (parser->m_unparsedEntityDeclHandler)

   567 #define notationDeclHandler (parser->m_notationDeclHandler)

   568 #define startNamespaceDeclHandler \

   569         (parser->m_startNamespaceDeclHandler)

   570 #define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

   571 #define notStandaloneHandler (parser->m_notStandaloneHandler)

   572 #define externalEntityRefHandler \

   573         (parser->m_externalEntityRefHandler)

   574 #define externalEntityRefHandlerArg \

   575         (parser->m_externalEntityRefHandlerArg)

   576 #define internalEntityRefHandler \

   577         (parser->m_internalEntityRefHandler)

   578 #define skippedEntityHandler (parser->m_skippedEntityHandler)

   579 #define unknownEncodingHandler (parser->m_unknownEncodingHandler)

   580 #define elementDeclHandler (parser->m_elementDeclHandler)

   581 #define attlistDeclHandler (parser->m_attlistDeclHandler)

   582 #define entityDeclHandler (parser->m_entityDeclHandler)

   583 #define xmlDeclHandler (parser->m_xmlDeclHandler)

   584 #define encoding (parser->m_encoding)

   585 #define initEncoding (parser->m_initEncoding)

   586 #define internalEncoding (parser->m_internalEncoding)

   587 #define unknownEncodingMem (parser->m_unknownEncodingMem)

   588 #define unknownEncodingData (parser->m_unknownEncodingData)

   589 #define unknownEncodingHandlerData \

   590   (parser->m_unknownEncodingHandlerData)

   591 #define unknownEncodingRelease (parser->m_unknownEncodingRelease)

   592 #define protocolEncodingName (parser->m_protocolEncodingName)

   593 #define ns (parser->m_ns)

   594 #define ns_triplets (parser->m_ns_triplets)

   595 #define prologState (parser->m_prologState)

   596 #define processor (parser->m_processor)

   597 #define errorCode (parser->m_errorCode)

   598 #define eventPtr (parser->m_eventPtr)

   599 #define eventEndPtr (parser->m_eventEndPtr)

   600 #define positionPtr (parser->m_positionPtr)

   601 #define position (parser->m_position)

   602 #define openInternalEntities (parser->m_openInternalEntities)

   603 #define freeInternalEntities (parser->m_freeInternalEntities)

   604 #define defaultExpandInternalEntities \

   605         (parser->m_defaultExpandInternalEntities)

   606 #define tagLevel (parser->m_tagLevel)

   607 #define buffer (parser->m_buffer)

   608 #define bufferPtr (parser->m_bufferPtr)

   609 #define bufferEnd (parser->m_bufferEnd)

   610 #define parseEndByteIndex (parser->m_parseEndByteIndex)

   611 #define parseEndPtr (parser->m_parseEndPtr)

   612 #define bufferLim (parser->m_bufferLim)

   613 #define dataBuf (parser->m_dataBuf)

   614 #define dataBufEnd (parser->m_dataBufEnd)

   615 #define _dtd (parser->m_dtd)

   616 #define curBase (parser->m_curBase)

   617 #define declEntity (parser->m_declEntity)

   618 #define doctypeName (parser->m_doctypeName)

   619 #define doctypeSysid (parser->m_doctypeSysid)

   620 #define doctypePubid (parser->m_doctypePubid)

   621 #define declAttributeType (parser->m_declAttributeType)

   622 #define declNotationName (parser->m_declNotationName)

   623 #define declNotationPublicId (parser->m_declNotationPublicId)

   624 #define declElementType (parser->m_declElementType)

   625 #define declAttributeId (parser->m_declAttributeId)

   626 #define declAttributeIsCdata (parser->m_declAttributeIsCdata)

   627 #define declAttributeIsId (parser->m_declAttributeIsId)

   628 #define freeTagList (parser->m_freeTagList)

   629 #define freeBindingList (parser->m_freeBindingList)

   630 #define inheritedBindings (parser->m_inheritedBindings)

   631 #define tagStack (parser->m_tagStack)

   632 #define atts (parser->m_atts)

   633 #define attsSize (parser->m_attsSize)

   634 #define nSpecifiedAtts (parser->m_nSpecifiedAtts)

   635 #define idAttIndex (parser->m_idAttIndex)

   636 #define nsAtts (parser->m_nsAtts)

   637 #define nsAttsVersion (parser->m_nsAttsVersion)

   638 #define nsAttsPower (parser->m_nsAttsPower)

   639 #define tempPool (parser->m_tempPool)

   640 #define temp2Pool (parser->m_temp2Pool)

   641 #define groupConnector (parser->m_groupConnector)

   642 #define groupSize (parser->m_groupSize)

   643 #define namespaceSeparator (parser->m_namespaceSeparator)

   644 #define parentParser (parser->m_parentParser)

   645 #define ps_parsing (parser->m_parsingStatus.parsing)

   646 #define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

   647 #ifdef XML_DTD

   648 #define isParamEntity (parser->m_isParamEntity)

   649 #define useForeignDTD (parser->m_useForeignDTD)

   650 #define paramEntityParsing (parser->m_paramEntityParsing)

   651 #endif /* XML_DTD */

   652 

   653 XML_Parser XMLCALL

   654 XML_ParserCreate(const XML_Char *encodingName)

   655 {

   656   return XML_ParserCreate_MM(encodingName, NULL, NULL);

   657 }

   658 

   659 XML_Parser XMLCALL

   660 XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)

   661 {

   662   XML_Char tmp[2];

   663   *tmp = nsSep;

   664   return XML_ParserCreate_MM(encodingName, NULL, tmp);

   665 }

   666 

   667 static const XML_Char implicitContext[] = {

   668   'x', 'm', 'l', '=', 'h', 't', 't', 'p', ':', '/', '/',

   669   'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

   670   'X', 'M', 'L', '/', '1', '9', '9', '8', '/',

   671   'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'

   672 };

   673 

   674 XML_Parser XMLCALL

   675 XML_ParserCreate_MM(const XML_Char *encodingName,

   676                     const XML_Memory_Handling_Suite *memsuite,

   677                     const XML_Char *nameSep)

   678 {

   679   XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);

   680   if (parser != NULL && ns) {

   681     /* implicit context only set for root parser, since child

   682        parsers (i.e. external entity parsers) will inherit it

   683     */

   684     if (!setContext(parser, implicitContext)) {

   685       XML_ParserFree(parser);

   686       return NULL;

   687     }

   688   }

   689   return parser;

   690 }

   691 

   692 static XML_Parser

   693 parserCreate(const XML_Char *encodingName,

   694              const XML_Memory_Handling_Suite *memsuite,

   695              const XML_Char *nameSep,

   696              DTD *dtd)

   697 {

   698   XML_Parser parser;

   699 

   700   if (memsuite) {

   701     XML_Memory_Handling_Suite *mtemp;

   702     parser = (XML_Parser)

   703       memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));

   704     if (parser != NULL) {

   705       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

   706       mtemp->malloc_fcn = memsuite->malloc_fcn;

   707       mtemp->realloc_fcn = memsuite->realloc_fcn;

   708       mtemp->free_fcn = memsuite->free_fcn;

   709     }

   710   }

   711   else {

   712     XML_Memory_Handling_Suite *mtemp;

   713     parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));

   714     if (parser != NULL) {

   715       mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);

   716       mtemp->malloc_fcn = malloc;

   717       mtemp->realloc_fcn = realloc;

   718       mtemp->free_fcn = free;

   719     }

   720   }

   721 

   722   if (!parser)

   723     return parser;

   724 

   725   buffer = NULL;

   726   bufferLim = NULL;

   727 

   728   attsSize = INIT_ATTS_SIZE;

   729   atts = (ATTRIBUTE *)MALLOC(attsSize * sizeof(ATTRIBUTE));

   730   if (atts == NULL) {

   731     FREE(parser);

   732     return NULL;

   733   }

   734   dataBuf = (XML_Char *)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));

   735   if (dataBuf == NULL) {

   736     FREE(atts);

   737     FREE(parser);

   738     return NULL;

   739   }

   740   dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;

   741 

   742   if (dtd)

   743     _dtd = dtd;

   744   else {

   745     _dtd = dtdCreate(&parser->m_mem);

   746     if (_dtd == NULL) {

   747       FREE(dataBuf);

   748       FREE(atts);

   749       FREE(parser);

   750       return NULL;

   751     }

   752   }

   753 

   754   freeBindingList = NULL;

   755   freeTagList = NULL;

   756   freeInternalEntities = NULL;

   757 

   758   groupSize = 0;

   759   groupConnector = NULL;

   760 

   761   unknownEncodingHandler = NULL;

   762   unknownEncodingHandlerData = NULL;

   763 

   764   namespaceSeparator = '!';

   765   ns = XML_FALSE;

   766   ns_triplets = XML_FALSE;

   767 

   768   nsAtts = NULL;

   769   nsAttsVersion = 0;

   770   nsAttsPower = 0;

   771 

   772   poolInit(&tempPool, &(parser->m_mem));

   773   poolInit(&temp2Pool, &(parser->m_mem));

   774   parserInit(parser, encodingName);

   775 

   776   if (encodingName && !protocolEncodingName) {

   777     XML_ParserFree(parser);

   778     return NULL;

   779   }

   780 

   781   if (nameSep) {

   782     ns = XML_TRUE;

   783     internalEncoding = XmlGetInternalEncodingNS();

   784     namespaceSeparator = *nameSep;

   785   }

   786   else {

   787     internalEncoding = XmlGetInternalEncoding();

   788   }

   789 

   790   return parser;

   791 }

   792 

   793 static void

   794 parserInit(XML_Parser parser, const XML_Char *encodingName)

   795 {

   796   processor = prologInitProcessor;

   797   XmlPrologStateInit(&prologState);

   798   protocolEncodingName = (encodingName != NULL

   799                           ? poolCopyString(&tempPool, encodingName)

   800                           : NULL);

   801   curBase = NULL;

   802   XmlInitEncoding(&initEncoding, &encoding, 0);

   803   userData = NULL;

   804   handlerArg = NULL;

   805   startElementHandler = NULL;

   806   endElementHandler = NULL;

   807   characterDataHandler = NULL;

   808   processingInstructionHandler = NULL;

   809   commentHandler = NULL;

   810   startCdataSectionHandler = NULL;

   811   endCdataSectionHandler = NULL;

   812   defaultHandler = NULL;

   813   startDoctypeDeclHandler = NULL;

   814   endDoctypeDeclHandler = NULL;

   815   unparsedEntityDeclHandler = NULL;

   816   notationDeclHandler = NULL;

   817   startNamespaceDeclHandler = NULL;

   818   endNamespaceDeclHandler = NULL;

   819   notStandaloneHandler = NULL;

   820   externalEntityRefHandler = NULL;

   821   externalEntityRefHandlerArg = parser;

   822   skippedEntityHandler = NULL;

   823   elementDeclHandler = NULL;

   824   attlistDeclHandler = NULL;

   825   entityDeclHandler = NULL;

   826   xmlDeclHandler = NULL;

   827   bufferPtr = buffer;

   828   bufferEnd = buffer;

   829   parseEndByteIndex = 0;

   830   parseEndPtr = NULL;

   831   declElementType = NULL;

   832   declAttributeId = NULL;

   833   declEntity = NULL;

   834   doctypeName = NULL;

   835   doctypeSysid = NULL;

   836   doctypePubid = NULL;

   837   declAttributeType = NULL;

   838   declNotationName = NULL;

   839   declNotationPublicId = NULL;

   840   declAttributeIsCdata = XML_FALSE;

   841   declAttributeIsId = XML_FALSE;

   842   memset(&position, 0, sizeof(POSITION));

   843   errorCode = XML_ERROR_NONE;

   844   eventPtr = NULL;

   845   eventEndPtr = NULL;

   846   positionPtr = NULL;

   847   openInternalEntities = NULL;

   848   defaultExpandInternalEntities = XML_TRUE;

   849   tagLevel = 0;

   850   tagStack = NULL;

   851   inheritedBindings = NULL;

   852   nSpecifiedAtts = 0;

   853   unknownEncodingMem = NULL;

   854   unknownEncodingRelease = NULL;

   855   unknownEncodingData = NULL;

   856   parentParser = NULL;

   857   ps_parsing = XML_INITIALIZED;

   858 #ifdef XML_DTD

   859   isParamEntity = XML_FALSE;

   860   useForeignDTD = XML_FALSE;

   861   paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

   862 #endif

   863 }

   864 

   865 /* moves list of bindings to freeBindingList */

   866 static void FASTCALL

   867 moveToFreeBindingList(XML_Parser parser, BINDING *bindings)

   868 {

   869   while (bindings) {

   870     BINDING *b = bindings;

   871     bindings = bindings->nextTagBinding;

   872     b->nextTagBinding = freeBindingList;

   873     freeBindingList = b;

   874   }

   875 }

   876 

   877 XML_Bool XMLCALL

   878 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

   879 {

   880   TAG *tStk;

   881   OPEN_INTERNAL_ENTITY *openEntityList;

   882   if (parentParser)

   883     return XML_FALSE;

   884   /* move tagStack to freeTagList */

   885   tStk = tagStack;

   886   while (tStk) {

   887     TAG *tag = tStk;

   888     tStk = tStk->parent;

   889     tag->parent = freeTagList;

   890     moveToFreeBindingList(parser, tag->bindings);

   891     tag->bindings = NULL;

   892     freeTagList = tag;

   893   }

   894   /* move openInternalEntities to freeInternalEntities */

   895   openEntityList = openInternalEntities;

   896   while (openEntityList) {

   897     OPEN_INTERNAL_ENTITY *openEntity = openEntityList;

   898     openEntityList = openEntity->next;

   899     openEntity->next = freeInternalEntities;

   900     freeInternalEntities = openEntity;

   901   }

   902   moveToFreeBindingList(parser, inheritedBindings);

   903   FREE(unknownEncodingMem);

   904   if (unknownEncodingRelease)

   905     unknownEncodingRelease(unknownEncodingData);

   906   poolClear(&tempPool);

   907   poolClear(&temp2Pool);

   908   parserInit(parser, encodingName);

   909   dtdReset(_dtd, &parser->m_mem);

   910   return setContext(parser, implicitContext);

   911 }

   912 

   913 enum XML_Status XMLCALL

   914 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

   915 {

   916   /* Block after XML_Parse()/XML_ParseBuffer() has been called.

   917      XXX There's no way for the caller to determine which of the

   918      XXX possible error cases caused the XML_STATUS_ERROR return.

   919   */

   920   if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

   921     return XML_STATUS_ERROR;

   922   if (encodingName == NULL)

   923     protocolEncodingName = NULL;

   924   else {

   925     protocolEncodingName = poolCopyString(&tempPool, encodingName);

   926     if (!protocolEncodingName)

   927       return XML_STATUS_ERROR;

   928   }

   929   return XML_STATUS_OK;

   930 }

   931 

   932 XML_Parser XMLCALL

   933 XML_ExternalEntityParserCreate(XML_Parser oldParser,

   934                                const XML_Char *context,

   935                                const XML_Char *encodingName)

   936 {

   937   XML_Parser parser = oldParser;

   938   DTD *newDtd = NULL;

   939   DTD *oldDtd = _dtd;

   940   XML_StartElementHandler oldStartElementHandler = startElementHandler;

   941   XML_EndElementHandler oldEndElementHandler = endElementHandler;

   942   XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;

   943   XML_ProcessingInstructionHandler oldProcessingInstructionHandler

   944       = processingInstructionHandler;

   945   XML_CommentHandler oldCommentHandler = commentHandler;

   946   XML_StartCdataSectionHandler oldStartCdataSectionHandler

   947       = startCdataSectionHandler;

   948   XML_EndCdataSectionHandler oldEndCdataSectionHandler

   949       = endCdataSectionHandler;

   950   XML_DefaultHandler oldDefaultHandler = defaultHandler;

   951   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler

   952       = unparsedEntityDeclHandler;

   953   XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;

   954   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler

   955       = startNamespaceDeclHandler;

   956   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler

   957       = endNamespaceDeclHandler;

   958   XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;

   959   XML_ExternalEntityRefHandler oldExternalEntityRefHandler

   960       = externalEntityRefHandler;

   961   XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;

   962   XML_UnknownEncodingHandler oldUnknownEncodingHandler

   963       = unknownEncodingHandler;

   964   XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;

   965   XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;

   966   XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;

   967   XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;

   968   ELEMENT_TYPE * oldDeclElementType = declElementType;

   969 

   970   void *oldUserData = userData;

   971   void *oldHandlerArg = handlerArg;

   972   XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;

   973   XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;

   974 #ifdef XML_DTD

   975   enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;

   976   int oldInEntityValue = prologState.inEntityValue;

   977 #endif

   978   XML_Bool oldns_triplets = ns_triplets;

   979 

   980 #ifdef XML_DTD

   981   if (!context)

   982     newDtd = oldDtd;

   983 #endif /* XML_DTD */

   984 

   985   /* Note that the magical uses of the pre-processor to make field

   986      access look more like C++ require that `parser' be overwritten

   987      here.  This makes this function more painful to follow than it

   988      would be otherwise.

   989   */

   990   if (ns) {

   991     XML_Char tmp[2];

   992     *tmp = namespaceSeparator;

   993     parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);

   994   }

   995   else {

   996     parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);

   997   }

   998 

   999   if (!parser)

  1000     return NULL;

  1001 

  1002   startElementHandler = oldStartElementHandler;

  1003   endElementHandler = oldEndElementHandler;

  1004   characterDataHandler = oldCharacterDataHandler;

  1005   processingInstructionHandler = oldProcessingInstructionHandler;

  1006   commentHandler = oldCommentHandler;

  1007   startCdataSectionHandler = oldStartCdataSectionHandler;

  1008   endCdataSectionHandler = oldEndCdataSectionHandler;

  1009   defaultHandler = oldDefaultHandler;

  1010   unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;

  1011   notationDeclHandler = oldNotationDeclHandler;

  1012   startNamespaceDeclHandler = oldStartNamespaceDeclHandler;

  1013   endNamespaceDeclHandler = oldEndNamespaceDeclHandler;

  1014   notStandaloneHandler = oldNotStandaloneHandler;

  1015   externalEntityRefHandler = oldExternalEntityRefHandler;

  1016   skippedEntityHandler = oldSkippedEntityHandler;

  1017   unknownEncodingHandler = oldUnknownEncodingHandler;

  1018   elementDeclHandler = oldElementDeclHandler;

  1019   attlistDeclHandler = oldAttlistDeclHandler;

  1020   entityDeclHandler = oldEntityDeclHandler;

  1021   xmlDeclHandler = oldXmlDeclHandler;

  1022   declElementType = oldDeclElementType;

  1023   userData = oldUserData;

  1024   if (oldUserData == oldHandlerArg)

  1025     handlerArg = userData;

  1026   else

  1027     handlerArg = parser;

  1028   if (oldExternalEntityRefHandlerArg != oldParser)

  1029     externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;

  1030   defaultExpandInternalEntities = oldDefaultExpandInternalEntities;

  1031   ns_triplets = oldns_triplets;

  1032   parentParser = oldParser;

  1033 #ifdef XML_DTD

  1034   paramEntityParsing = oldParamEntityParsing;

  1035   prologState.inEntityValue = oldInEntityValue;

  1036   if (context) {

  1037 #endif /* XML_DTD */

  1038     if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)

  1039       || !setContext(parser, context)) {

  1040       XML_ParserFree(parser);

  1041       return NULL;

  1042     }

  1043     processor = externalEntityInitProcessor;

  1044 #ifdef XML_DTD

  1045   }

  1046   else {

  1047     /* The DTD instance referenced by _dtd is shared between the document's

  1048        root parser and external PE parsers, therefore one does not need to

  1049        call setContext. In addition, one also *must* not call setContext,

  1050        because this would overwrite existing prefix->binding pointers in

  1051        _dtd with ones that get destroyed with the external PE parser.

  1052        This would leave those prefixes with dangling pointers.

  1053     */

  1054     isParamEntity = XML_TRUE;

  1055     XmlPrologStateInitExternalEntity(&prologState);

  1056     processor = externalParEntInitProcessor;

  1057   }

  1058 #endif /* XML_DTD */

  1059   return parser;

  1060 }

  1061 

  1062 static void FASTCALL

  1063 destroyBindings(BINDING *bindings, XML_Parser parser)

  1064 {

  1065   for (;;) {

  1066     BINDING *b = bindings;

  1067     if (!b)

  1068       break;

  1069     bindings = b->nextTagBinding;

  1070     FREE(b->uri);

  1071     FREE(b);

  1072   }

  1073 }

  1074 

  1075 void XMLCALL

  1076 XML_ParserFree(XML_Parser parser)

  1077 {

  1078   TAG *tagList;

  1079   OPEN_INTERNAL_ENTITY *entityList;

  1080   if (parser == NULL)

  1081     return;

  1082   /* free tagStack and freeTagList */

  1083   tagList = tagStack;

  1084   for (;;) {

  1085     TAG *p;

  1086     if (tagList == NULL) {

  1087       if (freeTagList == NULL)

  1088         break;

  1089       tagList = freeTagList;

  1090       freeTagList = NULL;

  1091     }

  1092     p = tagList;

  1093     tagList = tagList->parent;

  1094     FREE(p->buf);

  1095     destroyBindings(p->bindings, parser);

  1096     FREE(p);

  1097   }

  1098   /* free openInternalEntities and freeInternalEntities */

  1099   entityList = openInternalEntities;

  1100   for (;;) {

  1101     OPEN_INTERNAL_ENTITY *openEntity;

  1102     if (entityList == NULL) {

  1103       if (freeInternalEntities == NULL)

  1104         break;

  1105       entityList = freeInternalEntities;

  1106       freeInternalEntities = NULL;

  1107     }

  1108     openEntity = entityList;

  1109     entityList = entityList->next;

  1110     FREE(openEntity);

  1111   }

  1112 

  1113   destroyBindings(freeBindingList, parser);

  1114   destroyBindings(inheritedBindings, parser);

  1115   poolDestroy(&tempPool);

  1116   poolDestroy(&temp2Pool);

  1117 #ifdef XML_DTD

  1118   /* external parameter entity parsers share the DTD structure

  1119      parser->m_dtd with the root parser, so we must not destroy it

  1120   */

  1121   if (!isParamEntity && _dtd)

  1122 #else

  1123   if (_dtd)

  1124 #endif /* XML_DTD */

  1125     dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);

  1126   FREE((void *)atts);

  1127   FREE(groupConnector);

  1128   FREE(buffer);

  1129   FREE(dataBuf);

  1130   FREE(nsAtts);

  1131   FREE(unknownEncodingMem);

  1132   if (unknownEncodingRelease)

  1133     unknownEncodingRelease(unknownEncodingData);

  1134   FREE(parser);

  1135 }