Subversion Repositories Kolibri OS

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

   See the file COPYING for copying permission.

*/

#include 

#include                      /* memset(), memcpy() */

#include 

#include                      /* UINT_MAX */

#include                        /* time() */

#define XML_BUILDING_EXPAT 1

#ifdef COMPILED_FROM_DSP

#include "winconfig.h"

#elif defined(MACOS_CLASSIC)

#include "macconfig.h"

#elif defined(__amigaos__)

#include "amigaconfig.h"

#elif defined(__WATCOMC__)

#include "watcomconfig.h"

#elif defined(HAVE_EXPAT_CONFIG_H)

#include 

#endif /* ndef COMPILED_FROM_DSP */

#include "ascii.h"

#include "expat.h"

#ifdef XML_UNICODE

#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

#define XmlConvert XmlUtf16Convert

#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding

#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS

#define XmlEncode XmlUtf16Encode

/* Using pointer subtraction to convert to integer type. */

#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((char *)(s) - (char *)NULL) & 1))

typedef unsigned short ICHAR;

#else

#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

#define XmlConvert XmlUtf8Convert

#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

#define XmlEncode XmlUtf8Encode

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

typedef char ICHAR;

#endif

#ifndef XML_NS

#define XmlInitEncodingNS XmlInitEncoding

#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

#undef XmlGetInternalEncodingNS

#define XmlGetInternalEncodingNS XmlGetInternalEncoding

#define XmlParseXmlDeclNS XmlParseXmlDecl

#endif

#ifdef XML_UNICODE

#ifdef XML_UNICODE_WCHAR_T

#define XML_T(x) (const wchar_t)x

#define XML_L(x) L ## x

#else

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

#define XML_L(x) x

#endif

#else

#define XML_T(x) x

#define XML_L(x) x

#endif

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

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

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

#ifndef HAVE_MEMMOVE

#ifdef HAVE_BCOPY

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

#else

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

#endif /* HAVE_BCOPY */

#endif /* HAVE_MEMMOVE */

#include "internal.h"

#include "xmltok.h"

#include "xmlrole.h"

typedef const XML_Char *KEY;

typedef struct {

  KEY name;

} NAMED;

typedef struct {

  NAMED **v;

  unsigned char power;

  size_t size;

  size_t used;

  const XML_Memory_Handling_Suite *mem;

} HASH_TABLE;

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

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

*/

#ifdef XML_UNICODE

#define CHAR_HASH(h, c) \

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

#else

#define CHAR_HASH(h, c) \

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

#endif

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

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

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

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

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

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

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

*/

#define SECOND_HASH(hash, mask, power) \

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

#define PROBE_STEP(hash, mask, power) \

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

typedef struct {

  NAMED **p;

  NAMED **end;

} HASH_TABLE_ITER;

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

#define INIT_DATA_BUF_SIZE 1024

#define INIT_ATTS_SIZE 16

#define INIT_ATTS_VERSION 0xFFFFFFFF

#define INIT_BLOCK_SIZE 1024

#define INIT_BUFFER_SIZE 1024

#define EXPAND_SPARE 24

typedef struct binding {

  struct prefix *prefix;

  struct binding *nextTagBinding;

  struct binding *prevPrefixBinding;

  const struct attribute_id *attId;

  XML_Char *uri;

  int uriLen;

  int uriAlloc;

} BINDING;

typedef struct prefix {

  const XML_Char *name;

  BINDING *binding;

} PREFIX;

typedef struct {

  const XML_Char *str;

  const XML_Char *localPart;

  const XML_Char *prefix;

  int strLen;

  int uriLen;

  int prefixLen;

} TAG_NAME;

/* TAG represents an open element.

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

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

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

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

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

   document buffer.  If the element is open across calls to

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

   contain the 'raw' name as well.

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

   TAG objects in a free list.

*/

typedef struct tag {

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

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

  int rawNameLength;

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

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

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

  BINDING *bindings;

} TAG;

typedef struct {

  const XML_Char *name;

  const XML_Char *textPtr;

  int textLen;                  /* length in XML_Chars */

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

  const XML_Char *systemId;

  const XML_Char *base;

  const XML_Char *publicId;

  const XML_Char *notation;

  XML_Bool open;

  XML_Bool is_param;

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

} ENTITY;

typedef struct {

  enum XML_Content_Type         type;

  enum XML_Content_Quant        quant;

  const XML_Char *              name;

  int                           firstchild;

  int                           lastchild;

  int                           childcnt;

  int                           nextsib;

} CONTENT_SCAFFOLD;

#define INIT_SCAFFOLD_ELEMENTS 32

typedef struct block {

  struct block *next;

  int size;

  XML_Char s[1];

} BLOCK;

typedef struct {

  BLOCK *blocks;

  BLOCK *freeBlocks;

  const XML_Char *end;

  XML_Char *ptr;

  XML_Char *start;

  const XML_Memory_Handling_Suite *mem;

} STRING_POOL;

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

   an attribute has been specified. */

typedef struct attribute_id {

  XML_Char *name;

  PREFIX *prefix;

  XML_Bool maybeTokenized;

  XML_Bool xmlns;

} ATTRIBUTE_ID;

typedef struct {

  const ATTRIBUTE_ID *id;

  XML_Bool isCdata;

  const XML_Char *value;

} DEFAULT_ATTRIBUTE;

typedef struct {

  unsigned long version;

  unsigned long hash;

  const XML_Char *uriName;

} NS_ATT;

typedef struct {

  const XML_Char *name;

  PREFIX *prefix;

  const ATTRIBUTE_ID *idAtt;

  int nDefaultAtts;

  int allocDefaultAtts;

  DEFAULT_ATTRIBUTE *defaultAtts;

} ELEMENT_TYPE;

typedef struct {

  HASH_TABLE generalEntities;

  HASH_TABLE elementTypes;

  HASH_TABLE attributeIds;

  HASH_TABLE prefixes;

  STRING_POOL pool;

  STRING_POOL entityValuePool;

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

  XML_Bool keepProcessing;

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

     this includes the reference to an external subset */

  XML_Bool hasParamEntityRefs;

  XML_Bool standalone;

#ifdef XML_DTD

  /* indicates if external PE has been read */

  XML_Bool paramEntityRead;

  HASH_TABLE paramEntities;

#endif /* XML_DTD */

  PREFIX defaultPrefix;

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

  XML_Bool in_eldecl;

  CONTENT_SCAFFOLD *scaffold;

  unsigned contentStringLen;

  unsigned scaffSize;

  unsigned scaffCount;

  int scaffLevel;

  int *scaffIndex;

} DTD;

typedef struct open_internal_entity {

  const char *internalEventPtr;

  const char *internalEventEndPtr;

  struct open_internal_entity *next;

  ENTITY *entity;

  int startTagLevel;

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

} OPEN_INTERNAL_ENTITY;

typedef enum XML_Error PTRCALL Processor(XML_Parser parser,

                                         const char *start,

                                         const char *end,

                                         const char **endPtr);

static Processor prologProcessor;

static Processor prologInitProcessor;

static Processor contentProcessor;

static Processor cdataSectionProcessor;

#ifdef XML_DTD

static Processor ignoreSectionProcessor;

static Processor externalParEntProcessor;

static Processor externalParEntInitProcessor;

static Processor entityValueProcessor;

static Processor entityValueInitProcessor;

#endif /* XML_DTD */

static Processor epilogProcessor;

static Processor errorProcessor;

static Processor externalEntityInitProcessor;

static Processor externalEntityInitProcessor2;

static Processor externalEntityInitProcessor3;

static Processor externalEntityContentProcessor;

static Processor internalEntityProcessor;

static enum XML_Error

handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);

static enum XML_Error

processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

               const char *s, const char *next);

static enum XML_Error

initializeEncoding(XML_Parser parser);

static enum XML_Error

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

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

         XML_Bool haveMore);

static enum XML_Error

processInternalEntity(XML_Parser parser, ENTITY *entity,

                      XML_Bool betweenDecl);

static enum XML_Error

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

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

          XML_Bool haveMore);

static enum XML_Error

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

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

#ifdef XML_DTD

static enum XML_Error

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

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

#endif /* XML_DTD */

static enum XML_Error

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

          TAG_NAME *tagNamePtr, BINDING **bindingsPtr);

static enum XML_Error

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

           const XML_Char *uri, BINDING **bindingsPtr);

static int

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

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

static enum XML_Error

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

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

static enum XML_Error

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

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

static ATTRIBUTE_ID *

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

               const char *end);

static int

setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);

static enum XML_Error

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

                 const char *end);

static int

reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,

                            const char *start, const char *end);

static int

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

              const char *end);

static void

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

              const char *end);

static const XML_Char * getContext(XML_Parser parser);

static XML_Bool

setContext(XML_Parser parser, const XML_Char *context);

static void FASTCALL normalizePublicId(XML_Char *s);

static DTD * dtdCreate(const XML_Memory_Handling_Suite *ms);

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

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

static void

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

static int

dtdCopy(XML_Parser oldParser,

        DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);

static int

copyEntityTable(XML_Parser oldParser,

                HASH_TABLE *, STRING_POOL *, const HASH_TABLE *);

static NAMED *

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

static void FASTCALL

hashTableInit(HASH_TABLE *, const XML_Memory_Handling_Suite *ms);

static void FASTCALL hashTableClear(HASH_TABLE *);

static void FASTCALL hashTableDestroy(HASH_TABLE *);

static void FASTCALL

hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);

static NAMED * FASTCALL hashTableIterNext(HASH_TABLE_ITER *);

static void FASTCALL

poolInit(STRING_POOL *, const XML_Memory_Handling_Suite *ms);

static void FASTCALL poolClear(STRING_POOL *);

static void FASTCALL poolDestroy(STRING_POOL *);

static XML_Char *

poolAppend(STRING_POOL *pool, const ENCODING *enc,

           const char *ptr, const char *end);

static XML_Char *

poolStoreString(STRING_POOL *pool, const ENCODING *enc,

                const char *ptr, const char *end);

static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);

static const XML_Char * FASTCALL

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

static const XML_Char *

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

static const XML_Char * FASTCALL

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

static int FASTCALL nextScaffoldPart(XML_Parser parser);

static XML_Content * build_model(XML_Parser parser);

static ELEMENT_TYPE *

getElementType(XML_Parser parser, const ENCODING *enc,

               const char *ptr, const char *end);

static unsigned long generate_hash_secret_salt(void);

static XML_Bool startParsing(XML_Parser parser);

static XML_Parser

parserCreate(const XML_Char *encodingName,

             const XML_Memory_Handling_Suite *memsuite,

             const XML_Char *nameSep,

             DTD *dtd);

static void

parserInit(XML_Parser parser, const XML_Char *encodingName);

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

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

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

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

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

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

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

#define poolAppendChar(pool, c) \

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

   ? 0 \

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

struct XML_ParserStruct {

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

     macro works. */

  void *m_userData;

  void *m_handlerArg;

  char *m_buffer;

  const XML_Memory_Handling_Suite m_mem;

  /* first character to be parsed */

  const char *m_bufferPtr;

  /* past last character to be parsed */

  char *m_bufferEnd;

  /* allocated end of buffer */

  const char *m_bufferLim;

  XML_Index m_parseEndByteIndex;

  const char *m_parseEndPtr;

  XML_Char *m_dataBuf;

  XML_Char *m_dataBufEnd;

  XML_StartElementHandler m_startElementHandler;

  XML_EndElementHandler m_endElementHandler;

  XML_CharacterDataHandler m_characterDataHandler;

  XML_ProcessingInstructionHandler m_processingInstructionHandler;

  XML_CommentHandler m_commentHandler;

  XML_StartCdataSectionHandler m_startCdataSectionHandler;

  XML_EndCdataSectionHandler m_endCdataSectionHandler;

  XML_DefaultHandler m_defaultHandler;

  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;

  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;

  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;

  XML_NotationDeclHandler m_notationDeclHandler;

  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;

  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;

  XML_NotStandaloneHandler m_notStandaloneHandler;

  XML_ExternalEntityRefHandler m_externalEntityRefHandler;

  XML_Parser m_externalEntityRefHandlerArg;

  XML_SkippedEntityHandler m_skippedEntityHandler;

  XML_UnknownEncodingHandler m_unknownEncodingHandler;

  XML_ElementDeclHandler m_elementDeclHandler;

  XML_AttlistDeclHandler m_attlistDeclHandler;

  XML_EntityDeclHandler m_entityDeclHandler;

  XML_XmlDeclHandler m_xmlDeclHandler;

  const ENCODING *m_encoding;

  INIT_ENCODING m_initEncoding;

  const ENCODING *m_internalEncoding;

  const XML_Char *m_protocolEncodingName;

  XML_Bool m_ns;

  XML_Bool m_ns_triplets;

  void *m_unknownEncodingMem;

  void *m_unknownEncodingData;

  void *m_unknownEncodingHandlerData;

  void (XMLCALL *m_unknownEncodingRelease)(void *);

  PROLOG_STATE m_prologState;

  Processor *m_processor;

  enum XML_Error m_errorCode;

  const char *m_eventPtr;

  const char *m_eventEndPtr;

  const char *m_positionPtr;

  OPEN_INTERNAL_ENTITY *m_openInternalEntities;

  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;

  XML_Bool m_defaultExpandInternalEntities;

  int m_tagLevel;

  ENTITY *m_declEntity;

  const XML_Char *m_doctypeName;

  const XML_Char *m_doctypeSysid;

  const XML_Char *m_doctypePubid;

  const XML_Char *m_declAttributeType;

  const XML_Char *m_declNotationName;

  const XML_Char *m_declNotationPublicId;

  ELEMENT_TYPE *m_declElementType;

  ATTRIBUTE_ID *m_declAttributeId;

  XML_Bool m_declAttributeIsCdata;

  XML_Bool m_declAttributeIsId;

  DTD *m_dtd;

  const XML_Char *m_curBase;

  TAG *m_tagStack;

  TAG *m_freeTagList;

  BINDING *m_inheritedBindings;

  BINDING *m_freeBindingList;

  int m_attsSize;

  int m_nSpecifiedAtts;

  int m_idAttIndex;

  ATTRIBUTE *m_atts;

  NS_ATT *m_nsAtts;

  unsigned long m_nsAttsVersion;

  unsigned char m_nsAttsPower;

#ifdef XML_ATTR_INFO

  XML_AttrInfo *m_attInfo;

#endif

  POSITION m_position;

  STRING_POOL m_tempPool;

  STRING_POOL m_temp2Pool;

  char *m_groupConnector;

  unsigned int m_groupSize;

  XML_Char m_namespaceSeparator;

  XML_Parser m_parentParser;

  XML_ParsingStatus m_parsingStatus;

#ifdef XML_DTD

  XML_Bool m_isParamEntity;

  XML_Bool m_useForeignDTD;

  enum XML_ParamEntityParsing m_paramEntityParsing;

#endif

  unsigned long m_hash_secret_salt;

};

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

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

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

#define userData (parser->m_userData)

#define handlerArg (parser->m_handlerArg)

#define startElementHandler (parser->m_startElementHandler)

#define endElementHandler (parser->m_endElementHandler)

#define characterDataHandler (parser->m_characterDataHandler)

#define processingInstructionHandler \

        (parser->m_processingInstructionHandler)

#define commentHandler (parser->m_commentHandler)

#define startCdataSectionHandler \

        (parser->m_startCdataSectionHandler)

#define endCdataSectionHandler (parser->m_endCdataSectionHandler)

#define defaultHandler (parser->m_defaultHandler)

#define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

#define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

#define unparsedEntityDeclHandler \

        (parser->m_unparsedEntityDeclHandler)

#define notationDeclHandler (parser->m_notationDeclHandler)

#define startNamespaceDeclHandler \

        (parser->m_startNamespaceDeclHandler)

#define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

#define notStandaloneHandler (parser->m_notStandaloneHandler)

#define externalEntityRefHandler \

        (parser->m_externalEntityRefHandler)

#define externalEntityRefHandlerArg \

        (parser->m_externalEntityRefHandlerArg)

#define internalEntityRefHandler \

        (parser->m_internalEntityRefHandler)

#define skippedEntityHandler (parser->m_skippedEntityHandler)

#define unknownEncodingHandler (parser->m_unknownEncodingHandler)

#define elementDeclHandler (parser->m_elementDeclHandler)

#define attlistDeclHandler (parser->m_attlistDeclHandler)

#define entityDeclHandler (parser->m_entityDeclHandler)

#define xmlDeclHandler (parser->m_xmlDeclHandler)

#define encoding (parser->m_encoding)

#define initEncoding (parser->m_initEncoding)

#define internalEncoding (parser->m_internalEncoding)

#define unknownEncodingMem (parser->m_unknownEncodingMem)

#define unknownEncodingData (parser->m_unknownEncodingData)

#define unknownEncodingHandlerData \

  (parser->m_unknownEncodingHandlerData)

#define unknownEncodingRelease (parser->m_unknownEncodingRelease)

#define protocolEncodingName (parser->m_protocolEncodingName)

#define ns (parser->m_ns)

#define ns_triplets (parser->m_ns_triplets)

#define prologState (parser->m_prologState)

#define processor (parser->m_processor)

#define errorCode (parser->m_errorCode)

#define eventPtr (parser->m_eventPtr)

#define eventEndPtr (parser->m_eventEndPtr)

#define positionPtr (parser->m_positionPtr)

#define position (parser->m_position)

#define openInternalEntities (parser->m_openInternalEntities)

#define freeInternalEntities (parser->m_freeInternalEntities)

#define defaultExpandInternalEntities \

        (parser->m_defaultExpandInternalEntities)

#define tagLevel (parser->m_tagLevel)

#define buffer (parser->m_buffer)

#define bufferPtr (parser->m_bufferPtr)

#define bufferEnd (parser->m_bufferEnd)

#define parseEndByteIndex (parser->m_parseEndByteIndex)

#define parseEndPtr (parser->m_parseEndPtr)

#define bufferLim (parser->m_bufferLim)

#define dataBuf (parser->m_dataBuf)

#define dataBufEnd (parser->m_dataBufEnd)

#define _dtd (parser->m_dtd)

#define curBase (parser->m_curBase)

#define declEntity (parser->m_declEntity)

#define doctypeName (parser->m_doctypeName)

#define doctypeSysid (parser->m_doctypeSysid)

#define doctypePubid (parser->m_doctypePubid)

#define declAttributeType (parser->m_declAttributeType)

#define declNotationName (parser->m_declNotationName)

#define declNotationPublicId (parser->m_declNotationPublicId)

#define declElementType (parser->m_declElementType)

#define declAttributeId (parser->m_declAttributeId)

#define declAttributeIsCdata (parser->m_declAttributeIsCdata)

#define declAttributeIsId (parser->m_declAttributeIsId)

#define freeTagList (parser->m_freeTagList)

#define freeBindingList (parser->m_freeBindingList)

#define inheritedBindings (parser->m_inheritedBindings)

#define tagStack (parser->m_tagStack)

#define atts (parser->m_atts)

#define attsSize (parser->m_attsSize)

#define nSpecifiedAtts (parser->m_nSpecifiedAtts)

#define idAttIndex (parser->m_idAttIndex)

#define nsAtts (parser->m_nsAtts)

#define nsAttsVersion (parser->m_nsAttsVersion)

#define nsAttsPower (parser->m_nsAttsPower)

#define attInfo (parser->m_attInfo)

#define tempPool (parser->m_tempPool)

#define temp2Pool (parser->m_temp2Pool)

#define groupConnector (parser->m_groupConnector)

#define groupSize (parser->m_groupSize)

#define namespaceSeparator (parser->m_namespaceSeparator)

#define parentParser (parser->m_parentParser)

#define ps_parsing (parser->m_parsingStatus.parsing)

#define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

#ifdef XML_DTD

#define isParamEntity (parser->m_isParamEntity)

#define useForeignDTD (parser->m_useForeignDTD)

#define paramEntityParsing (parser->m_paramEntityParsing)

#endif /* XML_DTD */

#define hash_secret_salt (parser->m_hash_secret_salt)

XML_Parser XMLCALL

XML_ParserCreate(const XML_Char *encodingName)

{

  return XML_ParserCreate_MM(encodingName, NULL, NULL);

}

XML_Parser XMLCALL

XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)

{

  XML_Char tmp[2];

  *tmp = nsSep;

  return XML_ParserCreate_MM(encodingName, NULL, tmp);

}

static const XML_Char implicitContext[] = {

  ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,

  ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w,

  ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,

  ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9,

  ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,

  ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'

};

static unsigned long

generate_hash_secret_salt(void)

{

  unsigned int seed = time(NULL) % UINT_MAX;

  srand(seed);

  return rand();

}

static XML_Bool  /* only valid for root parser */

startParsing(XML_Parser parser)

{

    /* hash functions must be initialized before setContext() is called */

    if (hash_secret_salt == 0)

      hash_secret_salt = generate_hash_secret_salt();

    if (ns) {

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

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

      */

      return setContext(parser, implicitContext);

    }

    return XML_TRUE;

}

XML_Parser XMLCALL

XML_ParserCreate_MM(const XML_Char *encodingName,

                    const XML_Memory_Handling_Suite *memsuite,

                    const XML_Char *nameSep)

{

  return parserCreate(encodingName, memsuite, nameSep, NULL);

}

static XML_Parser

parserCreate(const XML_Char *encodingName,

             const XML_Memory_Handling_Suite *memsuite,

             const XML_Char *nameSep,

             DTD *dtd)

{

  XML_Parser parser;

  if (memsuite) {

    XML_Memory_Handling_Suite *mtemp;

    parser = (XML_Parser)

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

    if (parser != NULL) {

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

      mtemp->malloc_fcn = memsuite->malloc_fcn;

      mtemp->realloc_fcn = memsuite->realloc_fcn;

      mtemp->free_fcn = memsuite->free_fcn;

    }

  }

  else {

    XML_Memory_Handling_Suite *mtemp;

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

    if (parser != NULL) {

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

      mtemp->malloc_fcn = malloc;

      mtemp->realloc_fcn = realloc;

      mtemp->free_fcn = free;

    }

  }

  if (!parser)

    return parser;

  buffer = NULL;

  bufferLim = NULL;

  attsSize = INIT_ATTS_SIZE;

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

  if (atts == NULL) {

    FREE(parser);

    return NULL;

  }

#ifdef XML_ATTR_INFO

  attInfo = (XML_AttrInfo*)MALLOC(attsSize * sizeof(XML_AttrInfo));

  if (attInfo == NULL) {

    FREE(atts);

    FREE(parser);

    return NULL;

  }

#endif

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

  if (dataBuf == NULL) {

    FREE(atts);

#ifdef XML_ATTR_INFO

    FREE(attInfo);

#endif

    FREE(parser);

    return NULL;

  }

  dataBufEnd = dataBuf + INIT_DATA_BUF_SIZE;

  if (dtd)

    _dtd = dtd;

  else {

    _dtd = dtdCreate(&parser->m_mem);

    if (_dtd == NULL) {

      FREE(dataBuf);

      FREE(atts);

#ifdef XML_ATTR_INFO

      FREE(attInfo);

#endif

      FREE(parser);

      return NULL;

    }

  }

  freeBindingList = NULL;

  freeTagList = NULL;

  freeInternalEntities = NULL;

  groupSize = 0;

  groupConnector = NULL;

  unknownEncodingHandler = NULL;

  unknownEncodingHandlerData = NULL;

  namespaceSeparator = ASCII_EXCL;

  ns = XML_FALSE;

  ns_triplets = XML_FALSE;

  nsAtts = NULL;

  nsAttsVersion = 0;

  nsAttsPower = 0;

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

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

  parserInit(parser, encodingName);

  if (encodingName && !protocolEncodingName) {

    XML_ParserFree(parser);

    return NULL;

  }

  if (nameSep) {

    ns = XML_TRUE;

    internalEncoding = XmlGetInternalEncodingNS();

    namespaceSeparator = *nameSep;

  }

  else {

    internalEncoding = XmlGetInternalEncoding();

  }

  return parser;

}

static void

parserInit(XML_Parser parser, const XML_Char *encodingName)

{

  processor = prologInitProcessor;

  XmlPrologStateInit(&prologState);

  protocolEncodingName = (encodingName != NULL

                          ? poolCopyString(&tempPool, encodingName)

                          : NULL);

  curBase = NULL;

  XmlInitEncoding(&initEncoding, &encoding, 0);

  userData = NULL;

  handlerArg = NULL;

  startElementHandler = NULL;

  endElementHandler = NULL;

  characterDataHandler = NULL;

  processingInstructionHandler = NULL;

  commentHandler = NULL;

  startCdataSectionHandler = NULL;

  endCdataSectionHandler = NULL;

  defaultHandler = NULL;

  startDoctypeDeclHandler = NULL;

  endDoctypeDeclHandler = NULL;

  unparsedEntityDeclHandler = NULL;

  notationDeclHandler = NULL;

  startNamespaceDeclHandler = NULL;

  endNamespaceDeclHandler = NULL;

  notStandaloneHandler = NULL;

  externalEntityRefHandler = NULL;

  externalEntityRefHandlerArg = parser;

  skippedEntityHandler = NULL;

  elementDeclHandler = NULL;

  attlistDeclHandler = NULL;

  entityDeclHandler = NULL;

  xmlDeclHandler = NULL;

  bufferPtr = buffer;

  bufferEnd = buffer;

  parseEndByteIndex = 0;

  parseEndPtr = NULL;

  declElementType = NULL;

  declAttributeId = NULL;

  declEntity = NULL;

  doctypeName = NULL;

  doctypeSysid = NULL;

  doctypePubid = NULL;

  declAttributeType = NULL;

  declNotationName = NULL;

  declNotationPublicId = NULL;

  declAttributeIsCdata = XML_FALSE;

  declAttributeIsId = XML_FALSE;

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

  errorCode = XML_ERROR_NONE;

  eventPtr = NULL;

  eventEndPtr = NULL;

  positionPtr = NULL;

  openInternalEntities = NULL;

  defaultExpandInternalEntities = XML_TRUE;

  tagLevel = 0;

  tagStack = NULL;

  inheritedBindings = NULL;

  nSpecifiedAtts = 0;

  unknownEncodingMem = NULL;

  unknownEncodingRelease = NULL;

  unknownEncodingData = NULL;

  parentParser = NULL;

  ps_parsing = XML_INITIALIZED;

#ifdef XML_DTD

  isParamEntity = XML_FALSE;

  useForeignDTD = XML_FALSE;

  paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

#endif

  hash_secret_salt = 0;

}

/* moves list of bindings to freeBindingList */

static void FASTCALL

moveToFreeBindingList(XML_Parser parser, BINDING *bindings)

{

  while (bindings) {

    BINDING *b = bindings;

    bindings = bindings->nextTagBinding;

    b->nextTagBinding = freeBindingList;

    freeBindingList = b;

  }

}

XML_Bool XMLCALL

XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

{

  TAG *tStk;

  OPEN_INTERNAL_ENTITY *openEntityList;

  if (parentParser)

    return XML_FALSE;

  /* move tagStack to freeTagList */

  tStk = tagStack;

  while (tStk) {

    TAG *tag = tStk;

    tStk = tStk->parent;

    tag->parent = freeTagList;

    moveToFreeBindingList(parser, tag->bindings);

    tag->bindings = NULL;

    freeTagList = tag;

  }

  /* move openInternalEntities to freeInternalEntities */

  openEntityList = openInternalEntities;

  while (openEntityList) {

    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;

    openEntityList = openEntity->next;

    openEntity->next = freeInternalEntities;

    freeInternalEntities = openEntity;

  }

  moveToFreeBindingList(parser, inheritedBindings);

  FREE(unknownEncodingMem);

  if (unknownEncodingRelease)

    unknownEncodingRelease(unknownEncodingData);

  poolClear(&tempPool);

  poolClear(&temp2Pool);

  parserInit(parser, encodingName);

  dtdReset(_dtd, &parser->m_mem);

  return XML_TRUE;

}

enum XML_Status XMLCALL

XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

{

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

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

     XXX possible error cases caused the XML_STATUS_ERROR return.

  */

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

    return XML_STATUS_ERROR;

  if (encodingName == NULL)

    protocolEncodingName = NULL;

  else {

    protocolEncodingName = poolCopyString(&tempPool, encodingName);

    if (!protocolEncodingName)

      return XML_STATUS_ERROR;

  }

  return XML_STATUS_OK;

}

XML_Parser XMLCALL

XML_ExternalEntityParserCreate(XML_Parser oldParser,

                               const XML_Char *context,

                               const XML_Char *encodingName)

{

  XML_Parser parser = oldParser;

  DTD *newDtd = NULL;

  DTD *oldDtd = _dtd;

  XML_StartElementHandler oldStartElementHandler = startElementHandler;

  XML_EndElementHandler oldEndElementHandler = endElementHandler;

  XML_CharacterDataHandler oldCharacterDataHandler = characterDataHandler;

  XML_ProcessingInstructionHandler oldProcessingInstructionHandler

      = processingInstructionHandler;

  XML_CommentHandler oldCommentHandler = commentHandler;

  XML_StartCdataSectionHandler oldStartCdataSectionHandler

      = startCdataSectionHandler;

  XML_EndCdataSectionHandler oldEndCdataSectionHandler

      = endCdataSectionHandler;

  XML_DefaultHandler oldDefaultHandler = defaultHandler;

  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler

      = unparsedEntityDeclHandler;

  XML_NotationDeclHandler oldNotationDeclHandler = notationDeclHandler;

  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler

      = startNamespaceDeclHandler;

  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler

      = endNamespaceDeclHandler;

  XML_NotStandaloneHandler oldNotStandaloneHandler = notStandaloneHandler;

  XML_ExternalEntityRefHandler oldExternalEntityRefHandler

      = externalEntityRefHandler;

  XML_SkippedEntityHandler oldSkippedEntityHandler = skippedEntityHandler;

  XML_UnknownEncodingHandler oldUnknownEncodingHandler

      = unknownEncodingHandler;

  XML_ElementDeclHandler oldElementDeclHandler = elementDeclHandler;

  XML_AttlistDeclHandler oldAttlistDeclHandler = attlistDeclHandler;

  XML_EntityDeclHandler oldEntityDeclHandler = entityDeclHandler;

  XML_XmlDeclHandler oldXmlDeclHandler = xmlDeclHandler;

  ELEMENT_TYPE * oldDeclElementType = declElementType;

  void *oldUserData = userData;

  void *oldHandlerArg = handlerArg;

  XML_Bool oldDefaultExpandInternalEntities = defaultExpandInternalEntities;

  XML_Parser oldExternalEntityRefHandlerArg = externalEntityRefHandlerArg;

#ifdef XML_DTD

  enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;

  int oldInEntityValue = prologState.inEntityValue;

#endif

  XML_Bool oldns_triplets = ns_triplets;

  /* Note that the new parser shares the same hash secret as the old

     parser, so that dtdCopy and copyEntityTable can lookup values

     from hash tables associated with either parser without us having

     to worry which hash secrets each table has.

  */

  unsigned long oldhash_secret_salt = hash_secret_salt;

#ifdef XML_DTD

  if (!context)

    newDtd = oldDtd;

#endif /* XML_DTD */

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

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

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

     would be otherwise.

  */

  if (ns) {

    XML_Char tmp[2];

    *tmp = namespaceSeparator;

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

  }

  else {

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

  }

  if (!parser)

    return NULL;

  startElementHandler = oldStartElementHandler;

  endElementHandler = oldEndElementHandler;

  characterDataHandler = oldCharacterDataHandler;

  processingInstructionHandler = oldProcessingInstructionHandler;

  commentHandler = oldCommentHandler;

  startCdataSectionHandler = oldStartCdataSectionHandler;

  endCdataSectionHandler = oldEndCdataSectionHandler;

  defaultHandler = oldDefaultHandler;

  unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;

  notationDeclHandler = oldNotationDeclHandler;

  startNamespaceDeclHandler = oldStartNamespaceDeclHandler;

  endNamespaceDeclHandler = oldEndNamespaceDeclHandler;

  notStandaloneHandler = oldNotStandaloneHandler;

  externalEntityRefHandler = oldExternalEntityRefHandler;

  skippedEntityHandler = oldSkippedEntityHandler;

  unknownEncodingHandler = oldUnknownEncodingHandler;

  elementDeclHandler = oldElementDeclHandler;

  attlistDeclHandler = oldAttlistDeclHandler;

  entityDeclHandler = oldEntityDeclHandler;

  xmlDeclHandler = oldXmlDeclHandler;

  declElementType = oldDeclElementType;

  userData = oldUserData;

  if (oldUserData == oldHandlerArg)

    handlerArg = userData;

  else

    handlerArg = parser;

  if (oldExternalEntityRefHandlerArg != oldParser)

    externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;

  defaultExpandInternalEntities = oldDefaultExpandInternalEntities;

  ns_triplets = oldns_triplets;

  hash_secret_salt = oldhash_secret_salt;

  parentParser = oldParser;

#ifdef XML_DTD

  paramEntityParsing = oldParamEntityParsing;

  prologState.inEntityValue = oldInEntityValue;

  if (context) {

#endif /* XML_DTD */

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

      || !setContext(parser, context)) {

      XML_ParserFree(parser);

      return NULL;

    }

    processor = externalEntityInitProcessor;

#ifdef XML_DTD

  }

  else {

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

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

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

       because this would overwrite existing prefix->binding pointers in

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

       This would leave those prefixes with dangling pointers.

    */

    isParamEntity = XML_TRUE;

    XmlPrologStateInitExternalEntity(&prologState);

    processor = externalParEntInitProcessor;

  }

#endif /* XML_DTD */

  return parser;

}

static void FASTCALL

destroyBindings(BINDING *bindings, XML_Parser parser)

{

  for (;;) {

    BINDING *b = bindings;

    if (!b)

      break;

    bindings = b->nextTagBinding;

    FREE(b->uri);

    FREE(b);

  }

}

void XMLCALL