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

     2    See the file COPYING for copying permission.

     3    Portion Copyright © 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

     4 */

     5 

     6 // This file produces 9 "unreferenced formal parameter" warnings on MS and CW

     7 #if defined(__VC32__)

     8 #pragma warning ( disable : 4100 )

     9 

    10 #if !defined(_DEBUG)

    11 // This file produces 1 "unreachable code" warning on MS for UREL builds

    12 #pragma warning ( disable : 4702 )

    13 #endif // _DEBUG

    14 

    15 #elif defined(__CW32__)

    16 #pragma warn_unusedarg off

    17 #endif

    18 

    19 #include <stddef.h>

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

    21 

    22 #include "expat_config.h"

    23 #include "expat.h"

    24 

    25 #ifdef XML_UNICODE

    26 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

    27 #define XmlConvert XmlUtf16Convert

    28 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding

    29 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS

    30 #define XmlEncode XmlUtf16Encode

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

    32 typedef unsigned short ICHAR;

    33 #else

    34 #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

    35 #define XmlConvert XmlUtf8Convert

    36 #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

    37 #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

    38 #define XmlEncode XmlUtf8Encode

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

    40 typedef char ICHAR;

    41 #endif

    42 

    43 

    44 #ifndef XML_NS

    45 

    46 #define XmlInitEncodingNS XmlInitEncoding

    47 #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

    48 #undef XmlGetInternalEncodingNS

    49 #define XmlGetInternalEncodingNS XmlGetInternalEncoding

    50 #define XmlParseXmlDeclNS XmlParseXmlDecl

    51 

    52 #endif

    53 

    54 #ifdef XML_UNICODE

    55 

    56 #ifdef XML_UNICODE_WCHAR_T

    57 #define XML_T(x) (wchar_t)x

    58 #define XML_L(x) L ## x

    59 #else

    60 #define XML_T(x) (unsigned short)x

    61 #define XML_L(x) x

    62 #endif

    63 

    64 #else

    65 

    66 #define XML_T(x) x

    67 #define XML_L(x) x

    68 

    69 #endif

    70 

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

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

    73 

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

    75 #ifndef HAVE_MEMMOVE

    76 #ifdef HAVE_BCOPY

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

    78 #else

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

    80 #endif /* HAVE_BCOPY */

    81 #endif /* HAVE_MEMMOVE */

    82 

    83 #include "internal.h"

    84 #include "xmltok.h"

    85 #include "xmlrole.h"

    86 

    87 typedef const XML_Char *KEY;

    88 

    89 typedef struct {

    90   KEY name;

    91 } NAMED;

    92 

    93 typedef struct {

    94   NAMED **v;

    95   size_t size;

    96   size_t used;

    97   size_t usedLim;

    98   XML_Memory_Handling_Suite *mem;

    99 } HASH_TABLE;

   100 

   101 typedef struct {

   102   NAMED **p;

   103   NAMED **end;

   104 } HASH_TABLE_ITER;

   105 

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

   107 #define INIT_DATA_BUF_SIZE 1024

   108 #define INIT_ATTS_SIZE 16

   109 #define INIT_BLOCK_SIZE 1024

   110 #define INIT_BUFFER_SIZE 1024

   111 

   112 #define EXPAND_SPARE 24

   113 

   114 typedef struct binding {

   115   struct prefix *prefix;

   116   struct binding *nextTagBinding;

   117   struct binding *prevPrefixBinding;

   118   const struct attribute_id *attId;

   119   XML_Char *uri;

   120   int uriLen;

   121   int uriAlloc;

   122 } BINDING;

   123 

   124 typedef struct prefix {

   125   const XML_Char *name;

   126   BINDING *binding;

   127 } PREFIX;

   128 

   129 typedef struct {

   130   const XML_Char *str;

   131   const XML_Char *localPart;

   132   const XML_Char *prefix;

   133   int strLen;

   134   int uriLen;

   135   int prefixLen;

   136 } TAG_NAME;

   137 

   138 /* TAG represents an open element.

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

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

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

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

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

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

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

   146    contain the 'raw' name as well.

   147 

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

   149    TAG objects in a free list.

   150 */

   151 typedef struct tag {

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

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

   154   int rawNameLength;

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

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

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

   158   BINDING *bindings;

   159 } TAG;

   160 

   161 typedef struct {

   162   const XML_Char *name;

   163   const XML_Char *textPtr;

   164   int textLen;

   165   const XML_Char *systemId;

   166   const XML_Char *base;

   167   const XML_Char *publicId;

   168   const XML_Char *notation;

   169   XML_Bool open;

   170   XML_Bool is_param;

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

   172 } ENTITY;

   173 

   174 typedef struct {

   175   enum XML_Content_Type         type;

   176   enum XML_Content_Quant        quant;

   177   const XML_Char *              name;

   178   int                           firstchild;

   179   int                           lastchild;

   180   int                           childcnt;

   181   int                           nextsib;

   182 } CONTENT_SCAFFOLD;

   183 

   184 #define INIT_SCAFFOLD_ELEMENTS 32

   185 

   186 typedef struct block {

   187   struct block *next;

   188   int size;

   189   XML_Char s[1];

   190 } BLOCK;

   191 

   192 typedef struct {

   193   BLOCK *blocks;

   194   BLOCK *freeBlocks;

   195   const XML_Char *end;

   196   XML_Char *ptr;

   197   XML_Char *start;

   198   XML_Memory_Handling_Suite *mem;

   199 } STRING_POOL;

   200 

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

   202    an attribute has been specified. */

   203 typedef struct attribute_id {

   204   XML_Char *name;

   205   PREFIX *prefix;

   206   XML_Bool maybeTokenized;

   207   XML_Bool xmlns;

   208 } ATTRIBUTE_ID;

   209 

   210 typedef struct {

   211   const ATTRIBUTE_ID *id;

   212   XML_Bool isCdata;

   213   const XML_Char *value;

   214 } DEFAULT_ATTRIBUTE;

   215 

   216 typedef struct {

   217   const XML_Char *name;

   218   PREFIX *prefix;

   219   const ATTRIBUTE_ID *idAtt;

   220   int nDefaultAtts;

   221   int allocDefaultAtts;

   222   DEFAULT_ATTRIBUTE *defaultAtts;

   223 } ELEMENT_TYPE;

   224 

   225 typedef struct {

   226   HASH_TABLE generalEntities;

   227   HASH_TABLE elementTypes;

   228   HASH_TABLE attributeIds;

   229   HASH_TABLE prefixes;

   230   STRING_POOL pool;

   231   STRING_POOL entityValuePool;

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

   233   XML_Bool keepProcessing;

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

   235      any external subset is considered an external PE reference */

   236   XML_Bool hasParamEntityRefs;

   237   XML_Bool standalone;

   238 #ifdef XML_DTD

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

   240   XML_Bool paramEntityRead;

   241   HASH_TABLE paramEntities;

   242 #endif /* XML_DTD */

   243   PREFIX defaultPrefix;

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

   245   XML_Bool in_eldecl;

   246   CONTENT_SCAFFOLD *scaffold;

   247   unsigned contentStringLen;

   248   unsigned scaffSize;

   249   unsigned scaffCount;

   250   int scaffLevel;

   251   int *scaffIndex;

   252 } DTD;

   253 

   254 typedef struct open_internal_entity {

   255   const char *internalEventPtr;

   256   const char *internalEventEndPtr;

   257   struct open_internal_entity *next;

   258   ENTITY *entity;

   259 } OPEN_INTERNAL_ENTITY;

   260 

   261 typedef enum XML_Error FASTCALL Processor(XML_Parser parser,

   262                                           const char *start,

   263                                           const char *end,

   264                                           const char **endPtr);

   265 

   266 static Processor prologProcessor;

   267 static Processor prologInitProcessor;

   268 static Processor contentProcessor;

   269 static Processor cdataSectionProcessor;

   270 #ifdef XML_DTD

   271 static Processor ignoreSectionProcessor;

   272 static Processor externalParEntProcessor;

   273 static Processor externalParEntInitProcessor;

   274 static Processor entityValueProcessor;

   275 static Processor entityValueInitProcessor;

   276 #endif /* XML_DTD */

   277 static Processor epilogProcessor;

   278 static Processor errorProcessor;

   279 #ifndef SYMBIAN_MIN_SIZE

   280 static Processor externalEntityInitProcessor;

   281 static Processor externalEntityInitProcessor2;

   282 static Processor externalEntityInitProcessor3;

   283 #endif // SYMBIAN_MIN_SIZE

   284 static Processor externalEntityContentProcessor;

   285 

   286 static enum XML_Error FASTCALL

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

   288 static enum XML_Error FASTCALL

   289 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

   290                const char *, const char *);

   291 static enum XML_Error FASTCALL

   292 initializeEncoding(XML_Parser parser);

   293 static enum XML_Error FASTCALL

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

   295          const char *end, int tok, const char *next, const char **nextPtr);

   296 

   297 #ifdef XML_DTD

   298 static enum XML_Error FASTCALL

   299 processInternalParamEntity(XML_Parser parser, ENTITY *entity);

   300 #endif

   301 

   302 static enum XML_Error FASTCALL

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

   304           const char *start, const char *end, const char **endPtr);

   305 static enum XML_Error FASTCALL

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

   307                const char *end, const char **nextPtr);

   308 #ifdef XML_DTD

   309 static enum XML_Error FASTCALL

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

   311                 const char *end, const char **nextPtr);

   312 #endif /* XML_DTD */

   313 static enum XML_Error FASTCALL

   314 storeAtts(XML_Parser parser, const ENCODING *,

   315           const char *s, TAG_NAME *tagNamePtr, BINDING **bindingsPtr);

   316 static int FASTCALL

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

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

   319 

   320 static int FASTCALL

   321 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *,

   322                 XML_Bool isCdata, XML_Bool isId, const XML_Char *dfltValue,

   323                 XML_Parser parser);

   324 

   325 static enum XML_Error FASTCALL

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

   327                     const char *, const char *, STRING_POOL *);

   328 static enum XML_Error FASTCALL

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

   330                      const char *, const char *, STRING_POOL *);

   331 static ATTRIBUTE_ID * FASTCALL

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

   333                const char *end);

   334 static int FASTCALL

   335 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);

   336 static enum XML_Error FASTCALL

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

   338                  const char *end);

   339 static int FASTCALL

   340 reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

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

   342 static int FASTCALL

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

   344               const char *end);

   345 static void FASTCALL

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

   347               const char *end);

   348 

   349 static const XML_Char * FASTCALL getContext(XML_Parser parser);

   350 static XML_Bool FASTCALL

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

   352 static void FASTCALL normalizePublicId(XML_Char *s);

   353 static void FASTCALL dtdInit(DTD *, XML_Parser parser);

   354 

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

   356 static void FASTCALL dtdReset(DTD *, XML_Parser parser);

   357 static void FASTCALL dtdDestroy(DTD *, XML_Parser parser);

   358 

   359 #ifndef SYMBIAN_MIN_SIZE

   360 static int FASTCALL dtdCopy(DTD *newDtd, const DTD *oldDtd, XML_Parser parser);

   361 static int FASTCALL copyEntityTable(HASH_TABLE *, STRING_POOL *,

   362                                     const HASH_TABLE *, XML_Parser parser);

   363 #endif // SYMBIAN_MIN_SIZE

   364 

   365 #ifdef XML_DTD

   366 static void FASTCALL dtdSwap(DTD *, DTD *);

   367 #endif /* XML_DTD */

   368 

   369 static NAMED * FASTCALL

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

   371 

   372 static void FASTCALL

   373 hashTableInit(HASH_TABLE *, XML_Memory_Handling_Suite *ms);

   374 

   375 static void FASTCALL hashTableClear(HASH_TABLE *);

   376 static void FASTCALL hashTableDestroy(HASH_TABLE *);

   377 static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);

   378 static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);

   379 static void FASTCALL poolInit(STRING_POOL *, XML_Memory_Handling_Suite *ms);

   380 static void FASTCALL poolClear(STRING_POOL *);

   381 static void FASTCALL poolDestroy(STRING_POOL *);

   382 static XML_Char * FASTCALL

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

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

   385 static XML_Char * FASTCALL

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

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

   388 

   389 static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);

   390 

   391 static int FASTCALL nextScaffoldPart(XML_Parser parser);

   392 static XML_Content * FASTCALL build_model(XML_Parser parser);

   393 

   394 static const XML_Char * FASTCALL

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

   396 

   397 #ifndef SYMBIAN_MIN_SIZE

   398 static const XML_Char * FASTCALL

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

   400 static const XML_Char * FASTCALL

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

   402 #endif // SYMBIAN_MIN_SIZE

   403 

   404 static ELEMENT_TYPE * FASTCALL

   405 getElementType(XML_Parser Paraser, const ENCODING *enc,

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

   407 

   408 static void FASTCALL

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

   410 

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

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

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

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

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

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

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

   418 #define poolAppendChar(pool, c) \

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

   420    ? 0 \

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

   422 

   423 struct XML_ParserStruct {

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

   425      macro works. */

   426   void *m_userData;

   427   void *m_handlerArg;

   428   char *m_buffer;

   429   XML_Memory_Handling_Suite m_mem;

   430   /* first character to be parsed */

   431   const char *m_bufferPtr;

   432   /* past last character to be parsed */

   433   char *m_bufferEnd;

   434   /* allocated end of buffer */

   435   const char *m_bufferLim;

   436   long m_parseEndByteIndex;

   437   const char *m_parseEndPtr;

   438   XML_Char *m_dataBuf;

   439   XML_Char *m_dataBufEnd;

   440   XML_StartElementHandler m_startElementHandler;

   441   XML_EndElementHandler m_endElementHandler;

   442   XML_CharacterDataHandler m_characterDataHandler;

   443   XML_ProcessingInstructionHandler m_processingInstructionHandler;

   444   XML_CommentHandler m_commentHandler;

   445   XML_StartCdataSectionHandler m_startCdataSectionHandler;

   446   XML_EndCdataSectionHandler m_endCdataSectionHandler;

   447   XML_DefaultHandler m_defaultHandler;

   448   XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;

   449   XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;

   450   XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;

   451   XML_NotationDeclHandler m_notationDeclHandler;

   452   XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;

   453   XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;

   454   XML_NotStandaloneHandler m_notStandaloneHandler;

   455   XML_ExternalEntityRefHandler m_externalEntityRefHandler;

   456   void *m_externalEntityRefHandlerArg;

   457   XML_SkippedEntityHandler m_skippedEntityHandler;

   458   XML_UnknownEncodingHandler m_unknownEncodingHandler;

   459   XML_ElementDeclHandler m_elementDeclHandler;

   460   XML_AttlistDeclHandler m_attlistDeclHandler;

   461   XML_EntityDeclHandler m_entityDeclHandler;

   462   XML_XmlDeclHandler m_xmlDeclHandler;

   463   const ENCODING *m_encoding;

   464   INIT_ENCODING m_initEncoding;

   465   const ENCODING *m_internalEncoding;

   466   const XML_Char *m_protocolEncodingName;

   467   XML_Bool m_ns;

   468   XML_Bool m_ns_triplets;

   469   void *m_unknownEncodingMem;

   470   void *m_unknownEncodingData;

   471   void *m_unknownEncodingHandlerData;

   472   void (*m_unknownEncodingRelease)(void *);

   473   PROLOG_STATE m_prologState;

   474   Processor *m_processor;

   475   enum XML_Error m_errorCode;

   476   const char *m_eventPtr;

   477   const char *m_eventEndPtr;

   478   const char *m_positionPtr;

   479   OPEN_INTERNAL_ENTITY *m_openInternalEntities;

   480   XML_Bool m_defaultExpandInternalEntities;

   481   int m_tagLevel;

   482   ENTITY *m_declEntity;

   483   const XML_Char *m_doctypeName;

   484   const XML_Char *m_doctypeSysid;

   485   const XML_Char *m_doctypePubid;

   486   const XML_Char *m_declAttributeType;

   487   const XML_Char *m_declNotationName;

   488   const XML_Char *m_declNotationPublicId;

   489   ELEMENT_TYPE *m_declElementType;

   490   ATTRIBUTE_ID *m_declAttributeId;

   491   XML_Bool m_declAttributeIsCdata;

   492   XML_Bool m_declAttributeIsId;

   493   DTD m_dtd;

   494   const XML_Char *m_curBase;

   495   TAG *m_tagStack;

   496   TAG *m_freeTagList;

   497   BINDING *m_inheritedBindings;

   498   BINDING *m_freeBindingList;

   499   int m_attsSize;

   500   int m_nSpecifiedAtts;

   501   int m_idAttIndex;

   502   ATTRIBUTE *m_atts;

   503   POSITION m_position;

   504   STRING_POOL m_tempPool;

   505   STRING_POOL m_temp2Pool;

   506   char *m_groupConnector;

   507   unsigned m_groupSize;

   508   XML_Char m_namespaceSeparator;

   509   XML_Parser m_parentParser;

   510 #ifdef XML_DTD

   511   XML_Bool m_isParamEntity;

   512   XML_Bool m_useForeignDTD;

   513   enum XML_ParamEntityParsing m_paramEntityParsing;

   514 #endif

   515 };

   516 

   517 #define MALLOC(s) ( (parser)->m_mem.malloc_fcn ( ((parser)->m_mem.allocData), (s) ) )

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

   519 #define FREE(p) ( (parser)->m_mem.free_fcn ( ((parser)->m_mem.allocData), (p) ) )

   520 

   521 #define userData (parser->m_userData)

   522 #define handlerArg (parser->m_handlerArg)

   523 #define startElementHandler (parser->m_startElementHandler)

   524 #define endElementHandler (parser->m_endElementHandler)

   525 #define characterDataHandler (parser->m_characterDataHandler)

   526 #define processingInstructionHandler \

   527         (parser->m_processingInstructionHandler)

   528 #define commentHandler (parser->m_commentHandler)

   529 #define startCdataSectionHandler \

   530         (parser->m_startCdataSectionHandler)

   531 #define endCdataSectionHandler (parser->m_endCdataSectionHandler)

   532 #define defaultHandler (parser->m_defaultHandler)

   533 #define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

   534 #define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

   535 #define unparsedEntityDeclHandler \

   536         (parser->m_unparsedEntityDeclHandler)

   537 #define notationDeclHandler (parser->m_notationDeclHandler)

   538 #define startNamespaceDeclHandler \

   539         (parser->m_startNamespaceDeclHandler)

   540 #define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

   541 #define notStandaloneHandler (parser->m_notStandaloneHandler)

   542 #define externalEntityRefHandler \

   543         (parser->m_externalEntityRefHandler)

   544 #define externalEntityRefHandlerArg \

   545         (parser->m_externalEntityRefHandlerArg)

   546 #define internalEntityRefHandler \

   547         (parser->m_internalEntityRefHandler)

   548 #define skippedEntityHandler (parser->m_skippedEntityHandler)

   549 #define unknownEncodingHandler (parser->m_unknownEncodingHandler)

   550 #define elementDeclHandler (parser->m_elementDeclHandler)

   551 #define attlistDeclHandler (parser->m_attlistDeclHandler)

   552 #define entityDeclHandler (parser->m_entityDeclHandler)

   553 #define xmlDeclHandler (parser->m_xmlDeclHandler)

   554 #define encoding (parser->m_encoding)

   555 #define initEncoding (parser->m_initEncoding)

   556 #define internalEncoding (parser->m_internalEncoding)

   557 #define unknownEncodingMem (parser->m_unknownEncodingMem)

   558 #define unknownEncodingData (parser->m_unknownEncodingData)

   559 #define unknownEncodingHandlerData \

   560   (parser->m_unknownEncodingHandlerData)

   561 #define unknownEncodingRelease (parser->m_unknownEncodingRelease)

   562 #define protocolEncodingName (parser->m_protocolEncodingName)

   563 #define ns (parser->m_ns)

   564 #define ns_triplets (parser->m_ns_triplets)

   565 #define prologState (parser->m_prologState)

   566 #define processor (parser->m_processor)

   567 #define errorCode (parser->m_errorCode)

   568 #define eventPtr (parser->m_eventPtr)

   569 #define eventEndPtr (parser->m_eventEndPtr)

   570 #define positionPtr (parser->m_positionPtr)

   571 #define position (parser->m_position)

   572 #define openInternalEntities (parser->m_openInternalEntities)

   573 #define defaultExpandInternalEntities \

   574         (parser->m_defaultExpandInternalEntities)

   575 #define tagLevel (parser->m_tagLevel)

   576 #define buffer (parser->m_buffer)

   577 #define bufferPtr (parser->m_bufferPtr)

   578 #define bufferEnd (parser->m_bufferEnd)

   579 #define parseEndByteIndex (parser->m_parseEndByteIndex)

   580 #define parseEndPtr (parser->m_parseEndPtr)

   581 #define bufferLim (parser->m_bufferLim)

   582 #define dataBuf (parser->m_dataBuf)

   583 #define dataBufEnd (parser->m_dataBufEnd)

   584 #define dtd (parser->m_dtd)

   585 #define curBase (parser->m_curBase)

   586 #define declEntity (parser->m_declEntity)

   587 #define doctypeName (parser->m_doctypeName)

   588 #define doctypeSysid (parser->m_doctypeSysid)

   589 #define doctypePubid (parser->m_doctypePubid)

   590 #define declAttributeType (parser->m_declAttributeType)

   591 #define declNotationName (parser->m_declNotationName)

   592 #define declNotationPublicId (parser->m_declNotationPublicId)

   593 #define declElementType (parser->m_declElementType)

   594 #define declAttributeId (parser->m_declAttributeId)

   595 #define declAttributeIsCdata (parser->m_declAttributeIsCdata)

   596 #define declAttributeIsId (parser->m_declAttributeIsId)

   597 #define freeTagList (parser->m_freeTagList)

   598 #define freeBindingList (parser->m_freeBindingList)

   599 #define inheritedBindings (parser->m_inheritedBindings)

   600 #define tagStack (parser->m_tagStack)

   601 #define atts (parser->m_atts)

   602 #define attsSize (parser->m_attsSize)

   603 #define nSpecifiedAtts (parser->m_nSpecifiedAtts)

   604 #define idAttIndex (parser->m_idAttIndex)

   605 #define tempPool (parser->m_tempPool)

   606 #define temp2Pool (parser->m_temp2Pool)

   607 #define groupConnector (parser->m_groupConnector)

   608 #define groupSize (parser->m_groupSize)

   609 #define namespaceSeparator (parser->m_namespaceSeparator)

   610 #define parentParser (parser->m_parentParser)

   611 #ifdef XML_DTD

   612 #define isParamEntity (parser->m_isParamEntity)

   613 #define useForeignDTD (parser->m_useForeignDTD)

   614 #define paramEntityParsing (parser->m_paramEntityParsing)

   615 #endif /* XML_DTD */

   616 

   617 #define parsing (processor != prologInitProcessor)

   618 

   619 #ifndef SYMBIAN_MIN_SIZE

   620 XML_Parser

   621 XML_ParserCreate(const XML_Char *encodingName)

   622 {

   623   return XML_ParserCreate_MM(encodingName, NULL, NULL);

   624 }

   625 #endif // SYMBIAN_MIN_SIZE

   626 

   627 #ifndef SYMBIAN_MIN_SIZE

   628 XML_Parser

   629 XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)

   630 {

   631   XML_Char tmp[2];

   632   *tmp = nsSep;

   633   return XML_ParserCreate_MM(encodingName, NULL, tmp);

   634 }

   635 #endif // SYMBIAN_MIN_SIZE

   636 

   637 inline void* internal_malloc(void* allocData, size_t size)

   638 { return malloc(size); }

   639 

   640 inline void* internal_realloc(void* allocData, void* ptr, size_t size)

   641 { return realloc(ptr, size); }

   642 

   643 inline void internal_free(void* allocData, void* ptr)

   644 { free(ptr); }

   645 

   646 XML_Parser

   647 XML_ParserCreate_MM(const XML_Char *encodingName,

   648                     const XML_Memory_Handling_Suite *memsuite,

   649                     const XML_Char *nameSep) {

   650   XML_Parser parser;

   651   static const XML_Char implicitContext[] = {

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

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

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

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

   656   };

   657 

   658 

   659   if (memsuite) {

   660     XML_Memory_Handling_Suite *mtemp;

   661     parser = (XML_Parser)memsuite->malloc_fcn(memsuite->allocData, sizeof(struct XML_ParserStruct));

   662     if (parser != NULL) {

   663       mtemp = &(parser->m_mem);

   664       mtemp->malloc_fcn = memsuite->malloc_fcn;

   665       mtemp->realloc_fcn = memsuite->realloc_fcn;

   666       mtemp->free_fcn = memsuite->free_fcn;

   667 	  mtemp->allocData = memsuite->allocData;

   668 

   669     }

   670   }

   671   else {

   672     XML_Memory_Handling_Suite *mtemp;

   673     parser = (XML_Parser)internal_malloc(0, sizeof(struct XML_ParserStruct));

   674     if (parser != NULL) {

   675       mtemp = &(parser->m_mem);

   676       mtemp->malloc_fcn = internal_malloc;

   677       mtemp->realloc_fcn = internal_realloc;

   678       mtemp->free_fcn = internal_free;

   679 	  mtemp->allocData = 0;

   680     }

   681   }

   682 

   683   if (!parser)

   684     return parser;

   685 

   686   buffer = NULL;

   687   bufferLim = NULL;

   688 

   689   attsSize = INIT_ATTS_SIZE;

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

   691   if (atts == NULL) {

   692     FREE(parser);

   693     return NULL;

   694   }

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

   696   if (dataBuf == NULL) {

   697     FREE(atts);

   698     FREE(parser);

   699     return NULL;

   700   }

   701   dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;

   702 

   703   freeBindingList = NULL;

   704   freeTagList = NULL;

   705 

   706   groupSize = 0;

   707   groupConnector = NULL;

   708 

   709   unknownEncodingHandler = NULL;

   710   unknownEncodingHandlerData = NULL;

   711 

   712   namespaceSeparator = '!';

   713   ns = XML_FALSE;

   714   ns_triplets = XML_FALSE;

   715 

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

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

   718   parserInit(parser, encodingName);

   719   dtdInit(&dtd, parser);

   720 

   721   if (!atts || !dataBuf || (encodingName && !protocolEncodingName)) {

   722     XML_ParserFree(parser);

   723     return NULL;

   724   }

   725 

   726   if (nameSep) {

   727     ns = XML_TRUE;

   728     internalEncoding = XmlGetInternalEncodingNS();

   729     namespaceSeparator = *nameSep;

   730 

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

   732       XML_ParserFree(parser);

   733       return NULL;

   734     }

   735   }

   736   else {

   737     internalEncoding = XmlGetInternalEncoding();

   738   }

   739 

   740   return parser;

   741 }

   742 

   743 static void FASTCALL

   744 parserInit(XML_Parser parser, const XML_Char *encodingName)

   745 {

   746   processor = prologInitProcessor;

   747   XmlPrologStateInit(&prologState);

   748   protocolEncodingName = (encodingName != NULL

   749                           ? poolCopyString(&tempPool, encodingName)

   750                           : NULL);

   751   curBase = NULL;

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

   753   userData = NULL;

   754   handlerArg = NULL;

   755   startElementHandler = NULL;

   756   endElementHandler = NULL;

   757   characterDataHandler = NULL;

   758   processingInstructionHandler = NULL;

   759   commentHandler = NULL;

   760   startCdataSectionHandler = NULL;

   761   endCdataSectionHandler = NULL;

   762   defaultHandler = NULL;

   763   startDoctypeDeclHandler = NULL;

   764   endDoctypeDeclHandler = NULL;

   765   unparsedEntityDeclHandler = NULL;

   766   notationDeclHandler = NULL;

   767   startNamespaceDeclHandler = NULL;

   768   endNamespaceDeclHandler = NULL;

   769   notStandaloneHandler = NULL;

   770   externalEntityRefHandler = NULL;

   771   externalEntityRefHandlerArg = parser;

   772   skippedEntityHandler = NULL;

   773   elementDeclHandler = NULL;

   774   attlistDeclHandler = NULL;

   775   entityDeclHandler = NULL;

   776   xmlDeclHandler = NULL;

   777   bufferPtr = buffer;

   778   bufferEnd = buffer;

   779   parseEndByteIndex = 0;

   780   parseEndPtr = NULL;

   781   declElementType = NULL;

   782   declAttributeId = NULL;

   783   declEntity = NULL;

   784   doctypeName = NULL;

   785   doctypeSysid = NULL;

   786   doctypePubid = NULL;

   787   declAttributeType = NULL;

   788   declNotationName = NULL;

   789   declNotationPublicId = NULL;

   790   declAttributeIsCdata = XML_FALSE;

   791   declAttributeIsId = XML_FALSE;

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

   793   errorCode = XML_ERROR_NONE;

   794   eventPtr = NULL;

   795   eventEndPtr = NULL;

   796   positionPtr = NULL;

   797   openInternalEntities = 0;

   798   defaultExpandInternalEntities = XML_TRUE;

   799   tagLevel = 0;

   800   tagStack = NULL;

   801   inheritedBindings = NULL;

   802   nSpecifiedAtts = 0;

   803   unknownEncodingMem = NULL;

   804   unknownEncodingRelease = NULL;

   805   unknownEncodingData = NULL;

   806   parentParser = NULL;

   807 #ifdef XML_DTD

   808   isParamEntity = XML_FALSE;

   809   useForeignDTD = XML_FALSE;

   810   paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

   811 #endif

   812 }

   813 

   814 /* moves list of bindings to freeBindingList */

   815 static void FASTCALL

   816 moveToFreeBindingList(XML_Parser parser, BINDING *bindings)

   817 {

   818   while (bindings) {

   819     BINDING *b = bindings;

   820     bindings = bindings->nextTagBinding;

   821     b->nextTagBinding = freeBindingList;

   822     freeBindingList = b;

   823   }

   824 }

   825 

   826 XML_Bool

   827 XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

   828 {

   829   TAG *tStk;

   830   if (parentParser) 

   831     return XML_FALSE;

   832   /* move tagStack to freeTagList */

   833   tStk = tagStack;

   834   while (tStk) {

   835     TAG *tag = tStk;

   836     tStk = tStk->parent;

   837     tag->parent = freeTagList;

   838     moveToFreeBindingList(parser, tag->bindings);

   839     tag->bindings = NULL;

   840     freeTagList = tag;

   841   }

   842   moveToFreeBindingList(parser, inheritedBindings);

   843   if (unknownEncodingMem)

   844     FREE(unknownEncodingMem);

   845   if (unknownEncodingRelease)

   846     unknownEncodingRelease(unknownEncodingData);

   847   poolClear(&tempPool);

   848   poolClear(&temp2Pool);

   849   parserInit(parser, encodingName);

   850   dtdReset(&dtd, parser);

   851   return XML_TRUE;

   852 }

   853 

   854 #ifndef SYMBIAN_MIN_SIZE

   855 int

   856 XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

   857 {

   858   /* block after XML_Parse()/XML_ParseBuffer() has been called */

   859   if (parsing)

   860     return 0;

   861   if (encodingName == NULL)

   862     protocolEncodingName = NULL;

   863   else {

   864     protocolEncodingName = poolCopyString(&tempPool, encodingName);

   865     if (!protocolEncodingName)

   866       return 0;

   867   }

   868   return 1;

   869 }

   870 #endif // SYMBIAN_MIN_SIZE

   871 

   872 #ifndef SYMBIAN_MIN_SIZE

   873 XML_Parser

   874 XML_ExternalEntityParserCreate(XML_Parser oldParser,

   875                                const XML_Char *context,

   876                                const XML_Char *encodingName)

   877 {

   878   XML_Parser parser = oldParser;

   879   DTD *oldDtd = &dtd;

   880   XML_StartElementHandler oldStartElementHandler = startElementHandler;

   881   XML_EndElementHandler oldEndElementHandler = endElementHandler;

   882   XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;

   883   XML_ProcessingInstructionHandler oldProcessingInstructionHandler

   884       = processingInstructionHandler;

   885   XML_CommentHandler oldCommentHandler = commentHandler;

   886   XML_StartCdataSectionHandler oldStartCdataSectionHandler

   887       = startCdataSectionHandler;

   888   XML_EndCdataSectionHandler oldEndCdataSectionHandler

   889       = endCdataSectionHandler;

   890   XML_DefaultHandler oldDefaultHandler = defaultHandler;

   891   XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler

   892       = unparsedEntityDeclHandler;

   893   XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;

   894   XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler

   895       = startNamespaceDeclHandler;

   896   XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler

   897       = endNamespaceDeclHandler;

   898   XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;

   899   XML_ExternalEntityRefHandler oldExternalEntityRefHandler

   900       = externalEntityRefHandler;

   901   XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;

   902   XML_UnknownEncodingHandler oldUnknownEncodingHandler

   903       = unknownEncodingHandler;

   904   XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;

   905   XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;

   906   XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;

   907   XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;

   908   ELEMENT_TYPE * oldDeclElementType = declElementType;

   909 

   910   void *oldUserData = userData;

   911   void *oldHandlerArg = handlerArg;

   912   XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;

   913   void *oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;

   914 #ifdef XML_DTD

   915   int oldParamEntityParsing = paramEntityParsing;

   916   int oldInEntityValue = prologState.inEntityValue;

   917 #endif

   918   XML_Bool oldns_triplets = ns_triplets;

   919 

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

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

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

   923      would be otherwise.

   924   */

   925   if (ns) {

   926     XML_Char tmp[2];

   927 

   928     *tmp = namespaceSeparator;

   929     parser = XML_ParserCreate_MM(encodingName, &parser->m_mem,

   930                                  tmp);

   931   }

   932   else {

   933     parser = XML_ParserCreate_MM(encodingName, &parser->m_mem,

   934                                  NULL);

   935   }

   936 

   937   if (!parser)

   938     return NULL;

   939 

   940   startElementHandler = oldStartElementHandler;

   941   endElementHandler = oldEndElementHandler;

   942   characterDataHandler = oldCharacterDataHandler;

   943   processingInstructionHandler = oldProcessingInstructionHandler;

   944   commentHandler = oldCommentHandler;

   945   startCdataSectionHandler = oldStartCdataSectionHandler;

   946   endCdataSectionHandler = oldEndCdataSectionHandler;

   947   defaultHandler = oldDefaultHandler;

   948   unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;

   949   notationDeclHandler = oldNotationDeclHandler;

   950   startNamespaceDeclHandler = oldStartNamespaceDeclHandler;

   951   endNamespaceDeclHandler = oldEndNamespaceDeclHandler;

   952   notStandaloneHandler = oldNotStandaloneHandler;

   953   externalEntityRefHandler = oldExternalEntityRefHandler;

   954   skippedEntityHandler = oldSkippedEntityHandler;

   955   unknownEncodingHandler = oldUnknownEncodingHandler;

   956   elementDeclHandler = oldElementDeclHandler;

   957   attlistDeclHandler = oldAttlistDeclHandler;

   958   entityDeclHandler = oldEntityDeclHandler;

   959   xmlDeclHandler = oldXmlDeclHandler;

   960   declElementType = oldDeclElementType;

   961   userData = oldUserData;

   962   if (oldUserData == oldHandlerArg)

   963     handlerArg = userData;

   964   else

   965     handlerArg = parser;

   966   if (oldExternalEntityRefHandlerArg != oldParser)

   967     externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;

   968   defaultExpandInternalEntities = oldDefaultExpandInternalEntities;

   969   ns_triplets = oldns_triplets;

   970   parentParser = oldParser;

   971 #ifdef XML_DTD

   972   paramEntityParsing = oldParamEntityParsing;

   973   prologState.inEntityValue = oldInEntityValue;

   974   if (context) {

   975 #endif /* XML_DTD */

   976     if (!dtdCopy(&dtd, oldDtd, parser) || !setContext(parser, context)) {

   977       XML_ParserFree(parser);

   978       return NULL;

   979     }

   980     processor = externalEntityInitProcessor;

   981 #ifdef XML_DTD

   982   }

   983   else {

   984     dtdSwap(&dtd, oldDtd);

   985     isParamEntity = XML_TRUE;

   986     XmlPrologStateInitExternalEntity(&prologState);

   987     processor = externalParEntInitProcessor;

   988   }

   989 #endif /* XML_DTD */

   990   return parser;

   991 }

   992 #endif // SYMBIAN_MIN_SIZE

   993 

   994 static void FASTCALL

   995 destroyBindings(BINDING *bindings, XML_Parser parser)

   996 {

   997   for (;;) {

   998     BINDING *b = bindings;

   999     if (!b)

  1000       break;

  1001     bindings = b->nextTagBinding;

  1002     FREE(b->uri);

  1003     FREE(b);

  1004   }

  1005 }

  1006 

  1007 void

  1008 XML_ParserFree(XML_Parser parser)

  1009 {

  1010   for (;;) {

  1011     TAG *p;

  1012     if (tagStack == 0) {

  1013       if (freeTagList == NULL)

  1014         break;

  1015       tagStack = freeTagList;

  1016       freeTagList = NULL;

  1017     }

  1018     p = tagStack;

  1019     tagStack = tagStack->parent;

  1020     FREE(p->buf);

  1021     destroyBindings(p->bindings, parser);

  1022     FREE(p);

  1023   }

  1024   destroyBindings(freeBindingList, parser);

  1025   destroyBindings(inheritedBindings, parser);

  1026   poolDestroy(&tempPool);

  1027   poolDestroy(&temp2Pool);

  1028 #ifdef XML_DTD

  1029   if (isParamEntity)

  1030     dtdSwap(&dtd, &parentParser->m_dtd);

  1031 #endif /* XML_DTD */

  1032   dtdDestroy(&dtd, parser);

  1033   FREE((void *)atts);

  1034   if (groupConnector)

  1035     FREE(groupConnector);

  1036   if (buffer)

  1037     FREE(buffer);

  1038   FREE(dataBuf);

  1039   if (unknownEncodingMem)

  1040     FREE(unknownEncodingMem);

  1041   if (unknownEncodingRelease)

  1042     unknownEncodingRelease(unknownEncodingData);

  1043   FREE(parser);

  1044 }

  1045 

  1046 #ifndef SYMBIAN_MIN_SIZE

  1047 void

  1048 XML_UseParserAsHandlerArg(XML_Parser parser)

  1049 {

  1050   handlerArg = parser;

  1051 }

  1052 

  1053 enum XML_Error

  1054 XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)

  1055 {

  1056 #ifdef XML_DTD

  1057   /* block after XML_Parse()/XML_ParseBuffer() has been called */

  1058   if (parsing)

  1059     return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;

  1060   useForeignDTD = useDTD;

  1061   return XML_ERROR_NONE;

  1062 #else

  1063   return XML_ERROR_FEATURE_REQUIRES_XML_DTD;

  1064 #endif

  1065 }

  1066 #endif // SYMBIAN_MIN_SIZE

  1067 

  1068 void

  1069 XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)

  1070 {

  1071   /* block after XML_Parse()/XML_ParseBuffer() has been called */

  1072   if (parsing)

  1073     return;

  1074   ns_triplets = (XML_Bool)(do_nst ? XML_TRUE : XML_FALSE);

  1075 }

  1076 

  1077 void

  1078 XML_SetUserData(XML_Parser parser, void *p)

  1079 {

  1080   if (handlerArg == userData)

  1081     handlerArg = userData = p;

  1082   else

  1083     userData = p;

  1084 }

  1085 

  1086 #ifndef SYMBIAN_MIN_SIZE

  1087 int

  1088 XML_SetBase(XML_Parser parser, const XML_Char *p)

  1089 {

  1090   if (p) {

  1091     p = poolCopyString(&dtd.pool, p);

  1092     if (!p)

  1093       return 0;

  1094     curBase = p;

  1095   }

  1096   else

  1097     curBase = NULL;

  1098   return 1;

  1099 }

  1100 

  1101 const XML_Char *

  1102 XML_GetBase(XML_Parser parser)

  1103 {

  1104   return curBase;

  1105 }

  1106 

  1107 int

  1108 XML_GetSpecifiedAttributeCount(XML_Parser parser)

  1109 {

  1110   return nSpecifiedAtts;

  1111 }

  1112 

  1113 int

  1114 XML_GetIdAttributeIndex(XML_Parser parser)

  1115 {

  1116   return idAttIndex;

  1117 }

  1118 #endif // SYMBIAN_MIN_SIZE

  1119 

  1120 void

  1121 XML_SetElementHandler(XML_Parser parser,

  1122                       XML_StartElementHandler start,

  1123                       XML_EndElementHandler end)

  1124 {

  1125   startElementHandler = start;

  1126   endElementHandler = end;

  1127 }

  1128 

  1129 #ifndef SYMBIAN_MIN_SIZE

  1130 void

  1131 XML_SetStartElementHandler(XML_Parser parser,

  1132                            XML_StartElementHandler start) {

  1133   startElementHandler = start;

  1134 }

  1135