#include <stddef.h>

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

#define XML_BUILDING_EXPAT 1

#ifdef COMPILED_FROM_DSP

#include "winconfig.h"

#elif defined(MACOS_CLASSIC)

#include "macconfig.h"

#ifdef HAVE_EXPAT_CONFIG_H

#include <expat_config.h>

#endif /* ndef COMPILED_FROM_DSP */

#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

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

typedef unsigned short ICHAR;

#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;

#ifndef XML_NS

#define XmlInitEncodingNS XmlInitEncoding

#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

#undef XmlGetInternalEncodingNS

#define XmlGetInternalEncodingNS XmlGetInternalEncoding

#define XmlParseXmlDeclNS XmlParseXmlDecl

#ifdef XML_UNICODE

#ifdef XML_UNICODE_WCHAR_T

#define XML_T(x) (const wchar_t)x

#define XML_L(x) L ## x

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

#define XML_L(x) x

#define XML_T(x) x

#define XML_L(x) x

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

#ifndef HAVE_MEMMOVE

#ifdef HAVE_BCOPY

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

#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;

#ifdef XML_UNICODE

#define CHAR_HASH(h, c) \

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

#define CHAR_HASH(h, c) \

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

#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 {

} 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;

typedef struct tag {

} TAG;

typedef struct {

const XML_Char *name;

const XML_Char *textPtr;

int textLen;

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 {

} 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;

typedef struct attribute_id {

} 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;

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 {

} 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 enum XML_Error

handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);

static enum XML_Error

processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

const char *, const char *);

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);

static enum XML_Error

processInternalParamEntity(XML_Parser parser, ENTITY *entity);

static enum XML_Error

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

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

static enum XML_Error

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

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

#ifdef XML_DTD

static enum XML_Error

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

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

#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);

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(DTD *newDtd, const DTD *oldDtd, const XML_Memory_Handling_Suite *ms);

static int

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

static NAMED *

lookup(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 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 {

};

#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 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 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)

#ifdef XML_DTD

#define isParamEntity (parser->m_isParamEntity)

#define useForeignDTD (parser->m_useForeignDTD)

#define paramEntityParsing (parser->m_paramEntityParsing)

#endif /* XML_DTD */

#ifdef XML_DTD

#define parsing \

#define parsing \

#endif /* XML_DTD */

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[] = {

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

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

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

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

};

XML_Parser XMLCALL

XML_ParserCreate_MM(const XML_Char *encodingName,

const XML_Memory_Handling_Suite *memsuite,

const XML_Char *nameSep)

{

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

if (parser != NULL && ns) {

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

if (!setContext(parser, implicitContext)) {

XML_ParserFree(parser);

return NULL;

}

}

return parser;

}

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;

}

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

if (dataBuf == NULL) {

FREE(atts);

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);

FREE(parser);

return NULL;

}

}

freeBindingList = NULL;

freeTagList = NULL;

groupSize = 0;

groupConnector = NULL;

unknownEncodingHandler = NULL;

unknownEncodingHandlerData = NULL;

namespaceSeparator = '!';

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 = 0;

defaultExpandInternalEntities = XML_TRUE;

tagLevel = 0;

tagStack = NULL;

inheritedBindings = NULL;

nSpecifiedAtts = 0;

unknownEncodingMem = NULL;

unknownEncodingRelease = NULL;

unknownEncodingData = NULL;

parentParser = NULL;

#ifdef XML_DTD

isParamEntity = XML_FALSE;

useForeignDTD = XML_FALSE;

paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;

}

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;

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;

}

moveToFreeBindingList(parser, inheritedBindings);

FREE(unknownEncodingMem);

if (unknownEncodingRelease)

unknownEncodingRelease(unknownEncodingData);

poolClear(&tempPool);

poolClear(&temp2Pool);

parserInit(parser, encodingName);

dtdReset(_dtd, &parser->m_mem);

return setContext(parser, implicitContext);

}

enum XML_Status XMLCALL

XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

{

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

if (parsing)

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;

XML_Bool oldns_triplets = ns_triplets;

#ifdef XML_DTD

if (!context)

newDtd = oldDtd;

#endif /* XML_DTD */

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

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;