struct prefix *prefix;

struct binding *nextTagBinding;

struct binding *prevPrefixBinding;

const struct attribute_id *attId;

XML_Char *uri;

int uriLen;

int uriAlloc;

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;

struct block *next;

int size;

XML_Char s[1];

XML_Char *name;

PREFIX *prefix;

XML_Bool maybeTokenized;

XML_Bool xmlns;

const char *internalEventPtr;

const char *internalEventEndPtr;

struct open_internal_entity *next;

ENTITY *entity;

int startTagLevel;

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

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

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;

{

XML_Char tmp[2];

*tmp = nsSep;

return XML_ParserCreate_MM(encodingName, NULL, tmp);

{

#if defined(_WIN32_WCE)

unsigned int seed = GetTickCount();

#else

unsigned int seed = time(NULL) % UINT_MAX;

#endif

srand(seed);

return rand();

{

/* 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

return setContext(parser, implicitContext);

}

return XML_TRUE;

const XML_Memory_Handling_Suite *memsuite,

const XML_Char *nameSep)

{

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

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;

{

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;

{

while (bindings) {

BINDING *b = bindings;

bindings = bindings->nextTagBinding;

b->nextTagBinding = freeBindingList;

freeBindingList = b;

}

{

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;

{

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

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;

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