embedaddon/expat/lib/xmlparse.c - diff

Return to xmlparse.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / lib

Diff for /embedaddon/expat/lib/xmlparse.c between versions 1.1.1.1.2.1 and 1.1.1.2

version 1.1.1.1.2.1, 2013/07/22 01:14:39	version 1.1.1.2, 2014/06/15 16:09:43
Line 5	Line 5
#include <stddef.h>	#include <stddef.h>
#include <string.h> /* memset(), memcpy() */	#include <string.h> /* memset(), memcpy() */
#include <assert.h>	#include <assert.h>
	#include <limits.h> /* UINT_MAX */
	#include <time.h> /* time() */

#define XML_BUILDING_EXPAT 1	#define XML_BUILDING_EXPAT 1

Line 12	Line 14
#include "winconfig.h"	#include "winconfig.h"
#elif defined(MACOS_CLASSIC)	#elif defined(MACOS_CLASSIC)
#include "macconfig.h"	#include "macconfig.h"
#elif defined(__amigaos4__)	#elif defined(__amigaos__)
#include "amigaconfig.h"	#include "amigaconfig.h"
#elif defined(__WATCOMC__)	#elif defined(__WATCOMC__)
#include "watcomconfig.h"	#include "watcomconfig.h"
Line 327 processXmlDecl(XML_Parser parser, int isGeneralTextEnt	Line 329 processXmlDecl(XML_Parser parser, int isGeneralTextEnt
static enum XML_Error	static enum XML_Error
initializeEncoding(XML_Parser parser);	initializeEncoding(XML_Parser parser);
static enum XML_Error	static enum XML_Error
doProlog(XML_Parser parser, const ENCODING enc, const char s,	doProlog(XML_Parser parser, const ENCODING enc, const char s,
const char end, int tok, const char next, const char **nextPtr,	const char end, int tok, const char next, const char **nextPtr,
XML_Bool haveMore);	XML_Bool haveMore);
static enum XML_Error	static enum XML_Error
processInternalEntity(XML_Parser parser, ENTITY *entity,	processInternalEntity(XML_Parser parser, ENTITY *entity,
XML_Bool betweenDecl);	XML_Bool betweenDecl);
static enum XML_Error	static enum XML_Error
doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,	doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
const char start, const char end, const char **endPtr,	const char start, const char end, const char **endPtr,
XML_Bool haveMore);	XML_Bool haveMore);
static enum XML_Error	static enum XML_Error
doCdataSection(XML_Parser parser, const ENCODING , const char *startPtr,	doCdataSection(XML_Parser parser, const ENCODING , const char *startPtr,
Line 353 static enum XML_Error	Line 355 static enum XML_Error
addBinding(XML_Parser parser, PREFIX prefix, const ATTRIBUTE_ID attId,	addBinding(XML_Parser parser, PREFIX prefix, const ATTRIBUTE_ID attId,
const XML_Char uri, BINDING *bindingsPtr);	const XML_Char uri, BINDING *bindingsPtr);
static int	static int
defineAttribute(ELEMENT_TYPE type, ATTRIBUTE_ID , XML_Bool isCdata,	defineAttribute(ELEMENT_TYPE type, ATTRIBUTE_ID , XML_Bool isCdata,
XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);	XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);
static enum XML_Error	static enum XML_Error
storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,	storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,
Line 391 static void dtdReset(DTD *p, const XML_Memory_Handling	Line 393 static void dtdReset(DTD *p, const XML_Memory_Handling
static void	static void
dtdDestroy(DTD p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite ms);	dtdDestroy(DTD p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite ms);
static int	static int
dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memory_Handling_Suite *ms);	dtdCopy(XML_Parser oldParser,
	DTD newDtd, const DTD oldDtd, const XML_Memory_Handling_Suite *ms);
static int	static int
copyEntityTable(HASH_TABLE , STRING_POOL , const HASH_TABLE *);	copyEntityTable(XML_Parser oldParser,
	HASH_TABLE , STRING_POOL , const HASH_TABLE *);
static NAMED *	static NAMED *
lookup(HASH_TABLE *table, KEY name, size_t createSize);	lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize);
static void FASTCALL	static void FASTCALL
hashTableInit(HASH_TABLE , const XML_Memory_Handling_Suite ms);	hashTableInit(HASH_TABLE , const XML_Memory_Handling_Suite ms);
static void FASTCALL hashTableClear(HASH_TABLE *);	static void FASTCALL hashTableClear(HASH_TABLE *);
Line 429 static ELEMENT_TYPE *	Line 432 static ELEMENT_TYPE *
getElementType(XML_Parser parser, const ENCODING *enc,	getElementType(XML_Parser parser, const ENCODING *enc,
const char ptr, const char end);	const char ptr, const char end);

	static unsigned long generate_hash_secret_salt(void);
	static XML_Bool startParsing(XML_Parser parser);

static XML_Parser	static XML_Parser
parserCreate(const XML_Char *encodingName,	parserCreate(const XML_Char *encodingName,
const XML_Memory_Handling_Suite *memsuite,	const XML_Memory_Handling_Suite *memsuite,
const XML_Char *nameSep,	const XML_Char *nameSep,
DTD *dtd);	DTD *dtd);

static void	static void
parserInit(XML_Parser parser, const XML_Char *encodingName);	parserInit(XML_Parser parser, const XML_Char *encodingName);

Line 533 struct XML_ParserStruct {	Line 540 struct XML_ParserStruct {
NS_ATT *m_nsAtts;	NS_ATT *m_nsAtts;
unsigned long m_nsAttsVersion;	unsigned long m_nsAttsVersion;
unsigned char m_nsAttsPower;	unsigned char m_nsAttsPower;
	#ifdef XML_ATTR_INFO
	XML_AttrInfo *m_attInfo;
	#endif
POSITION m_position;	POSITION m_position;
STRING_POOL m_tempPool;	STRING_POOL m_tempPool;
STRING_POOL m_temp2Pool;	STRING_POOL m_temp2Pool;
Line 546 struct XML_ParserStruct {	Line 556 struct XML_ParserStruct {
XML_Bool m_useForeignDTD;	XML_Bool m_useForeignDTD;
enum XML_ParamEntityParsing m_paramEntityParsing;	enum XML_ParamEntityParsing m_paramEntityParsing;
#endif	#endif
	unsigned long m_hash_secret_salt;
};	};

#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))	#define MALLOC(s) (parser->m_mem.malloc_fcn((s)))
Line 640 struct XML_ParserStruct {	Line 651 struct XML_ParserStruct {
#define nsAtts (parser->m_nsAtts)	#define nsAtts (parser->m_nsAtts)
#define nsAttsVersion (parser->m_nsAttsVersion)	#define nsAttsVersion (parser->m_nsAttsVersion)
#define nsAttsPower (parser->m_nsAttsPower)	#define nsAttsPower (parser->m_nsAttsPower)
	#define attInfo (parser->m_attInfo)
#define tempPool (parser->m_tempPool)	#define tempPool (parser->m_tempPool)
#define temp2Pool (parser->m_temp2Pool)	#define temp2Pool (parser->m_temp2Pool)
#define groupConnector (parser->m_groupConnector)	#define groupConnector (parser->m_groupConnector)
Line 653 struct XML_ParserStruct {	Line 665 struct XML_ParserStruct {
#define useForeignDTD (parser->m_useForeignDTD)	#define useForeignDTD (parser->m_useForeignDTD)
#define paramEntityParsing (parser->m_paramEntityParsing)	#define paramEntityParsing (parser->m_paramEntityParsing)
#endif /* XML_DTD */	#endif /* XML_DTD */
	#define hash_secret_salt (parser->m_hash_secret_salt)

XML_Parser XMLCALL	XML_Parser XMLCALL
XML_ParserCreate(const XML_Char *encodingName)	XML_ParserCreate(const XML_Char *encodingName)
Line 670 XML_ParserCreateNS(const XML_Char *encodingName, XML_C	Line 683 XML_ParserCreateNS(const XML_Char *encodingName, XML_C

static const XML_Char implicitContext[] = {	static const XML_Char implicitContext[] = {
ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p,	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_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_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_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_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e,
ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0'	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_Parser XMLCALL
XML_ParserCreate_MM(const XML_Char *encodingName,	XML_ParserCreate_MM(const XML_Char *encodingName,
const XML_Memory_Handling_Suite *memsuite,	const XML_Memory_Handling_Suite *memsuite,
const XML_Char *nameSep)	const XML_Char *nameSep)
{	{
XML_Parser parser = parserCreate(encodingName, memsuite, nameSep, NULL);	return parserCreate(encodingName, memsuite, nameSep, NULL);
if (parser != NULL && ns) {
/* implicit context only set for root parser, since child
parsers (i.e. external entity parsers) will inherit it
*/
if (!setContext(parser, implicitContext)) {
XML_ParserFree(parser);
return NULL;
}
}
return parser;
}	}

static XML_Parser	static XML_Parser
Line 737 parserCreate(const XML_Char *encodingName,	Line 763 parserCreate(const XML_Char *encodingName,
FREE(parser);	FREE(parser);
return NULL;	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));	dataBuf = (XML_Char )MALLOC(INIT_DATA_BUF_SIZE sizeof(XML_Char));
if (dataBuf == NULL) {	if (dataBuf == NULL) {
FREE(atts);	FREE(atts);
	#ifdef XML_ATTR_INFO
	FREE(attInfo);
	#endif
FREE(parser);	FREE(parser);
return NULL;	return NULL;
}	}
Line 752 parserCreate(const XML_Char *encodingName,	Line 789 parserCreate(const XML_Char *encodingName,
if (_dtd == NULL) {	if (_dtd == NULL) {
FREE(dataBuf);	FREE(dataBuf);
FREE(atts);	FREE(atts);
	#ifdef XML_ATTR_INFO
	FREE(attInfo);
	#endif
FREE(parser);	FREE(parser);
return NULL;	return NULL;
}	}
Line 866 parserInit(XML_Parser parser, const XML_Char *encoding	Line 906 parserInit(XML_Parser parser, const XML_Char *encoding
useForeignDTD = XML_FALSE;	useForeignDTD = XML_FALSE;
paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;	paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
#endif	#endif
	hash_secret_salt = 0;
}	}

/* moves list of bindings to freeBindingList */	/* moves list of bindings to freeBindingList */
Line 913 XML_ParserReset(XML_Parser parser, const XML_Char *enc	Line 954 XML_ParserReset(XML_Parser parser, const XML_Char *enc
poolClear(&temp2Pool);	poolClear(&temp2Pool);
parserInit(parser, encodingName);	parserInit(parser, encodingName);
dtdReset(_dtd, &parser->m_mem);	dtdReset(_dtd, &parser->m_mem);
return setContext(parser, implicitContext);	return XML_TRUE;
}	}

enum XML_Status XMLCALL	enum XML_Status XMLCALL
Line 982 XML_ExternalEntityParserCreate(XML_Parser oldParser,	Line 1023 XML_ExternalEntityParserCreate(XML_Parser oldParser,
int oldInEntityValue = prologState.inEntityValue;	int oldInEntityValue = prologState.inEntityValue;
#endif	#endif
XML_Bool oldns_triplets = ns_triplets;	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	#ifdef XML_DTD
if (!context)	if (!context)
Line 1035 XML_ExternalEntityParserCreate(XML_Parser oldParser,	Line 1082 XML_ExternalEntityParserCreate(XML_Parser oldParser,
externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;	externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
defaultExpandInternalEntities = oldDefaultExpandInternalEntities;	defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
ns_triplets = oldns_triplets;	ns_triplets = oldns_triplets;
	hash_secret_salt = oldhash_secret_salt;
parentParser = oldParser;	parentParser = oldParser;
#ifdef XML_DTD	#ifdef XML_DTD
paramEntityParsing = oldParamEntityParsing;	paramEntityParsing = oldParamEntityParsing;
prologState.inEntityValue = oldInEntityValue;	prologState.inEntityValue = oldInEntityValue;
if (context) {	if (context) {
#endif /* XML_DTD */	#endif /* XML_DTD */
if (!dtdCopy(_dtd, oldDtd, &parser->m_mem)	if (!dtdCopy(oldParser, _dtd, oldDtd, &parser->m_mem)
\|\| !setContext(parser, context)) {	\|\| !setContext(parser, context)) {
XML_ParserFree(parser);	XML_ParserFree(parser);
return NULL;	return NULL;
Line 1130 XML_ParserFree(XML_Parser parser)	Line 1178 XML_ParserFree(XML_Parser parser)
#endif /* XML_DTD */	#endif /* XML_DTD */
dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);	dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
FREE((void *)atts);	FREE((void *)atts);
	#ifdef XML_ATTR_INFO
	FREE((void *)attInfo);
	#endif
FREE(groupConnector);	FREE(groupConnector);
FREE(buffer);	FREE(buffer);
FREE(dataBuf);	FREE(dataBuf);
Line 1210 XML_GetIdAttributeIndex(XML_Parser parser)	Line 1261 XML_GetIdAttributeIndex(XML_Parser parser)
return idAttIndex;	return idAttIndex;
}	}

	#ifdef XML_ATTR_INFO
	const XML_AttrInfo * XMLCALL
	XML_GetAttributeInfo(XML_Parser parser)
	{
	return attInfo;
	}
	#endif

void XMLCALL	void XMLCALL
XML_SetElementHandler(XML_Parser parser,	XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,	XML_StartElementHandler start,
Line 1426 XML_SetParamEntityParsing(XML_Parser parser,	Line 1485 XML_SetParamEntityParsing(XML_Parser parser,
#endif	#endif
}	}

	int XMLCALL
	XML_SetHashSalt(XML_Parser parser,
	unsigned long hash_salt)
	{
	/* block after XML_Parse()/XML_ParseBuffer() has been called */
	if (ps_parsing == XML_PARSING \|\| ps_parsing == XML_SUSPENDED)
	return 0;
	hash_secret_salt = hash_salt;
	return 1;
	}

enum XML_Status XMLCALL	enum XML_Status XMLCALL
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)	XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
{	{
Line 1436 XML_Parse(XML_Parser parser, const char *s, int len, i	Line 1506 XML_Parse(XML_Parser parser, const char *s, int len, i
case XML_FINISHED:	case XML_FINISHED:
errorCode = XML_ERROR_FINISHED;	errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;	return XML_STATUS_ERROR;
	case XML_INITIALIZED:
	if (parentParser == NULL && !startParsing(parser)) {
	errorCode = XML_ERROR_NO_MEMORY;
	return XML_STATUS_ERROR;
	}
default:	default:
ps_parsing = XML_PARSING;	ps_parsing = XML_PARSING;
}	}
Line 1459 XML_Parse(XML_Parser parser, const char *s, int len, i	Line 1534 XML_Parse(XML_Parser parser, const char *s, int len, i
XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);	XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
positionPtr = bufferPtr;	positionPtr = bufferPtr;
return XML_STATUS_SUSPENDED;	return XML_STATUS_SUSPENDED;
case XML_INITIALIZED:	case XML_INITIALIZED:
case XML_PARSING:	case XML_PARSING:
ps_parsing = XML_FINISHED;	ps_parsing = XML_FINISHED;
/* fall through */	/* fall through */
Line 1494 XML_Parse(XML_Parser parser, const char *s, int len, i	Line 1569 XML_Parse(XML_Parser parser, const char *s, int len, i
break;	break;
case XML_INITIALIZED:	case XML_INITIALIZED:
case XML_PARSING:	case XML_PARSING:
result = XML_STATUS_OK;
if (isFinal) {	if (isFinal) {
ps_parsing = XML_FINISHED;	ps_parsing = XML_FINISHED;
return result;	return XML_STATUS_OK;
}	}
	/* fall through */
	default:
	result = XML_STATUS_OK;
}	}
}	}

Line 1513 XML_Parse(XML_Parser parser, const char *s, int len, i	Line 1590 XML_Parse(XML_Parser parser, const char *s, int len, i
: (char )REALLOC(buffer, len 2));	: (char )REALLOC(buffer, len 2));
if (temp == NULL) {	if (temp == NULL) {
errorCode = XML_ERROR_NO_MEMORY;	errorCode = XML_ERROR_NO_MEMORY;
return XML_STATUS_ERROR;
}
buffer = temp;
if (!buffer) {
errorCode = XML_ERROR_NO_MEMORY;
eventPtr = eventEndPtr = NULL;	eventPtr = eventEndPtr = NULL;
processor = errorProcessor;	processor = errorProcessor;
return XML_STATUS_ERROR;	return XML_STATUS_ERROR;
}	}
	buffer = temp;
bufferLim = buffer + len * 2;	bufferLim = buffer + len * 2;
}	}
memcpy(buffer, end, nLeftOver);	memcpy(buffer, end, nLeftOver);
Line 1559 XML_ParseBuffer(XML_Parser parser, int len, int isFina	Line 1632 XML_ParseBuffer(XML_Parser parser, int len, int isFina
case XML_FINISHED:	case XML_FINISHED:
errorCode = XML_ERROR_FINISHED;	errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR;	return XML_STATUS_ERROR;
	case XML_INITIALIZED:
	if (parentParser == NULL && !startParsing(parser)) {
	errorCode = XML_ERROR_NO_MEMORY;
	return XML_STATUS_ERROR;
	}
default:	default:
ps_parsing = XML_PARSING;	ps_parsing = XML_PARSING;
}	}
Line 1582 XML_ParseBuffer(XML_Parser parser, int len, int isFina	Line 1660 XML_ParseBuffer(XML_Parser parser, int len, int isFina
case XML_SUSPENDED:	case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;	result = XML_STATUS_SUSPENDED;
break;	break;
case XML_INITIALIZED:	case XML_INITIALIZED:
case XML_PARSING:	case XML_PARSING:
if (isFinal) {	if (isFinal) {
ps_parsing = XML_FINISHED;	ps_parsing = XML_FINISHED;
Line 1672 XML_GetBuffer(XML_Parser parser, int len)	Line 1750 XML_GetBuffer(XML_Parser parser, int len)
bufferPtr = buffer = newBuf;	bufferPtr = buffer = newBuf;
#endif /* not defined XML_CONTEXT_BYTES */	#endif /* not defined XML_CONTEXT_BYTES */
}	}
	eventPtr = eventEndPtr = NULL;
	positionPtr = NULL;
}	}
return bufferEnd;	return bufferEnd;
}	}
Line 1729 XML_ResumeParser(XML_Parser parser)	Line 1809 XML_ResumeParser(XML_Parser parser)
case XML_SUSPENDED:	case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED;	result = XML_STATUS_SUSPENDED;
break;	break;
case XML_INITIALIZED:	case XML_INITIALIZED:
case XML_PARSING:	case XML_PARSING:
if (ps_finalBuffer) {	if (ps_finalBuffer) {
ps_parsing = XML_FINISHED;	ps_parsing = XML_FINISHED;
Line 1956 XML_GetFeatureList(void)	Line 2036 XML_GetFeatureList(void)
#endif	#endif
#ifdef XML_LARGE_SIZE	#ifdef XML_LARGE_SIZE
{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},	{XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
#endif	#endif
	#ifdef XML_ATTR_INFO
	{XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
	#endif
{XML_FEATURE_END, NULL, 0}	{XML_FEATURE_END, NULL, 0}
};	};

Line 2019 contentProcessor(XML_Parser parser,	Line 2102 contentProcessor(XML_Parser parser,
const char *end,	const char *end,
const char **endPtr)	const char **endPtr)
{	{
enum XML_Error result = doContent(parser, 0, encoding, start, end,	enum XML_Error result = doContent(parser, 0, encoding, start, end,
endPtr, (XML_Bool)!ps_finalBuffer);	endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) {	if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser))	if (!storeRawNames(parser))
Line 2101 externalEntityInitProcessor3(XML_Parser parser,	Line 2184 externalEntityInitProcessor3(XML_Parser parser,
if (result != XML_ERROR_NONE)	if (result != XML_ERROR_NONE)
return result;	return result;
switch (ps_parsing) {	switch (ps_parsing) {
case XML_SUSPENDED:	case XML_SUSPENDED:
*endPtr = next;	*endPtr = next;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_FINISHED:	case XML_FINISHED:
Line 2135 externalEntityContentProcessor(XML_Parser parser,	Line 2218 externalEntityContentProcessor(XML_Parser parser,
const char *end,	const char *end,
const char **endPtr)	const char **endPtr)
{	{
enum XML_Error result = doContent(parser, 1, encoding, start, end,	enum XML_Error result = doContent(parser, 1, encoding, start, end,
endPtr, (XML_Bool)!ps_finalBuffer);	endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) {	if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser))	if (!storeRawNames(parser))
Line 2154 doContent(XML_Parser parser,	Line 2237 doContent(XML_Parser parser,
XML_Bool haveMore)	XML_Bool haveMore)
{	{
/* save one level of indirection */	/* save one level of indirection */
DTD * const dtd = _dtd;	DTD * const dtd = _dtd;

const char **eventPP;	const char **eventPP;
const char **eventEndPP;	const char **eventEndPP;
Line 2185 doContent(XML_Parser parser,	Line 2268 doContent(XML_Parser parser,
}	}
else if (defaultHandler)	else if (defaultHandler)
reportDefault(parser, enc, s, end);	reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for	/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?	XML_SUSPENDED, XML_FINISHED?
*/	*/
if (startTagLevel == 0)	if (startTagLevel == 0)
return XML_ERROR_NO_ELEMENTS;	return XML_ERROR_NO_ELEMENTS;
Line 2240 doContent(XML_Parser parser,	Line 2323 doContent(XML_Parser parser,
next - enc->minBytesPerChar);	next - enc->minBytesPerChar);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);	entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
poolDiscard(&dtd->pool);	poolDiscard(&dtd->pool);
/* First, determine if a check for an existing declaration is needed;	/* First, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal,	if yes, check that the entity exists, and that it is internal,
Line 2537 doContent(XML_Parser parser,	Line 2620 doContent(XML_Parser parser,
}	}
else if (defaultHandler)	else if (defaultHandler)
reportDefault(parser, enc, s, end);	reportDefault(parser, enc, s, end);
/* We are at the end of the final buffer, should we check for	/* We are at the end of the final buffer, should we check for
XML_SUSPENDED, XML_FINISHED?	XML_SUSPENDED, XML_FINISHED?
*/	*/
if (startTagLevel == 0) {	if (startTagLevel == 0) {
*eventPP = end;	*eventPP = end;
Line 2550 doContent(XML_Parser parser,	Line 2633 doContent(XML_Parser parser,
}	}
*nextPtr = end;	*nextPtr = end;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_TOK_DATA_CHARS:	case XML_TOK_DATA_CHARS:
{	{
XML_CharacterDataHandler charDataHandler = characterDataHandler;	XML_CharacterDataHandler charDataHandler = characterDataHandler;
if (charDataHandler) {	if (charDataHandler) {
Line 2590 doContent(XML_Parser parser,	Line 2673 doContent(XML_Parser parser,
}	}
*eventPP = s = next;	*eventPP = s = next;
switch (ps_parsing) {	switch (ps_parsing) {
case XML_SUSPENDED:	case XML_SUSPENDED:
*nextPtr = next;	*nextPtr = next;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_FINISHED:	case XML_FINISHED:
Line 2630 storeAtts(XML_Parser parser, const ENCODING *enc,	Line 2713 storeAtts(XML_Parser parser, const ENCODING *enc,
const XML_Char *localPart;	const XML_Char *localPart;

/* lookup the element type name */	/* lookup the element type name */
elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, tagNamePtr->str,0);	elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0);
if (!elementType) {	if (!elementType) {
const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);	const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
elementType = (ELEMENT_TYPE *)lookup(&dtd->elementTypes, name,	elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
sizeof(ELEMENT_TYPE));	sizeof(ELEMENT_TYPE));
if (!elementType)	if (!elementType)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
Line 2649 storeAtts(XML_Parser parser, const ENCODING *enc,	Line 2732 storeAtts(XML_Parser parser, const ENCODING *enc,
if (n + nDefaultAtts > attsSize) {	if (n + nDefaultAtts > attsSize) {
int oldAttsSize = attsSize;	int oldAttsSize = attsSize;
ATTRIBUTE *temp;	ATTRIBUTE *temp;
	#ifdef XML_ATTR_INFO
	XML_AttrInfo *temp2;
	#endif
attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;	attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
temp = (ATTRIBUTE )REALLOC((void )atts, attsSize * sizeof(ATTRIBUTE));	temp = (ATTRIBUTE )REALLOC((void )atts, attsSize * sizeof(ATTRIBUTE));
if (temp == NULL)	if (temp == NULL)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
atts = temp;	atts = temp;
	#ifdef XML_ATTR_INFO
	temp2 = (XML_AttrInfo )REALLOC((void )attInfo, attsSize * sizeof(XML_AttrInfo));
	if (temp2 == NULL)
	return XML_ERROR_NO_MEMORY;
	attInfo = temp2;
	#endif
if (n > oldAttsSize)	if (n > oldAttsSize)
XmlGetAttributes(enc, attStr, n, atts);	XmlGetAttributes(enc, attStr, n, atts);
}	}

appAtts = (const XML_Char **)atts;	appAtts = (const XML_Char **)atts;
for (i = 0; i < n; i++) {	for (i = 0; i < n; i++) {
	ATTRIBUTE *currAtt = &atts[i];
	#ifdef XML_ATTR_INFO
	XML_AttrInfo *currAttInfo = &attInfo[i];
	#endif
/* add the name and value to the attribute list */	/* add the name and value to the attribute list */
ATTRIBUTE_ID *attId = getAttributeId(parser, enc, atts[i].name,	ATTRIBUTE_ID *attId = getAttributeId(parser, enc, currAtt->name,
atts[i].name	currAtt->name
+ XmlNameLength(enc, atts[i].name));	+ XmlNameLength(enc, currAtt->name));
if (!attId)	if (!attId)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
	#ifdef XML_ATTR_INFO
	currAttInfo->nameStart = parseEndByteIndex - (parseEndPtr - currAtt->name);
	currAttInfo->nameEnd = currAttInfo->nameStart +
	XmlNameLength(enc, currAtt->name);
	currAttInfo->valueStart = parseEndByteIndex -
	(parseEndPtr - currAtt->valuePtr);
	currAttInfo->valueEnd = parseEndByteIndex - (parseEndPtr - currAtt->valueEnd);
	#endif
/* Detect duplicate attributes by their QNames. This does not work when	/* Detect duplicate attributes by their QNames. This does not work when
namespace processing is turned on and different prefixes for the same	namespace processing is turned on and different prefixes for the same
namespace are used. For this case we have a check further down.	namespace are used. For this case we have a check further down.
Line 2804 storeAtts(XML_Parser parser, const ENCODING *enc,	Line 2908 storeAtts(XML_Parser parser, const ENCODING *enc,
if (s[-1] == 2) { /* prefixed */	if (s[-1] == 2) { /* prefixed */
ATTRIBUTE_ID *id;	ATTRIBUTE_ID *id;
const BINDING *b;	const BINDING *b;
unsigned long uriHash = 0;	unsigned long uriHash = hash_secret_salt;
((XML_Char )s)[-1] = 0; / clear flag */	((XML_Char )s)[-1] = 0; / clear flag */
id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);	id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
b = id->prefix->binding;	b = id->prefix->binding;
if (!b)	if (!b)
return XML_ERROR_UNBOUND_PREFIX;	return XML_ERROR_UNBOUND_PREFIX;
Line 2828 storeAtts(XML_Parser parser, const ENCODING *enc,	Line 2932 storeAtts(XML_Parser parser, const ENCODING *enc,
} while (*s++);	} while (*s++);

{ /* Check hash table for duplicate of expanded name (uriName).	{ /* Check hash table for duplicate of expanded name (uriName).
Derived from code in lookup(HASH_TABLE *table, ...).	Derived from code in lookup(parser, HASH_TABLE *table, ...).
*/	*/
unsigned char step = 0;	unsigned char step = 0;
unsigned long mask = nsAttsSize - 1;	unsigned long mask = nsAttsSize - 1;
Line 2949 addBinding(XML_Parser parser, PREFIX *prefix, const AT	Line 3053 addBinding(XML_Parser parser, PREFIX *prefix, const AT
static const XML_Char xmlNamespace[] = {	static const XML_Char xmlNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,	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_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_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_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_n, ASCII_a, ASCII_m, ASCII_e, ASCII_s, ASCII_p, ASCII_a, ASCII_c,
ASCII_e, '\0'	ASCII_e, '\0'
};	};
static const int xmlLen =	static const int xmlLen =
(int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;	(int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
static const XML_Char xmlnsNamespace[] = {	static const XML_Char xmlnsNamespace[] = {
ASCII_h, ASCII_t, ASCII_t, ASCII_p, ASCII_COLON, ASCII_SLASH, ASCII_SLASH,	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_w, ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD,
ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,	ASCII_o, ASCII_r, ASCII_g, ASCII_SLASH, ASCII_2, ASCII_0, ASCII_0,
ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,	ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
ASCII_SLASH, '\0'	ASCII_SLASH, '\0'
};	};
static const int xmlnsLen =	static const int xmlnsLen =
(int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;	(int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;

XML_Bool mustBeXML = XML_FALSE;	XML_Bool mustBeXML = XML_FALSE;
XML_Bool isXML = XML_TRUE;	XML_Bool isXML = XML_TRUE;
XML_Bool isXMLNS = XML_TRUE;	XML_Bool isXMLNS = XML_TRUE;

BINDING *b;	BINDING *b;
int len;	int len;

Line 2996 addBinding(XML_Parser parser, PREFIX *prefix, const AT	Line 3100 addBinding(XML_Parser parser, PREFIX *prefix, const AT
if (isXML && (len > xmlLen \|\| uri[len] != xmlNamespace[len]))	if (isXML && (len > xmlLen \|\| uri[len] != xmlNamespace[len]))
isXML = XML_FALSE;	isXML = XML_FALSE;

if (!mustBeXML && isXMLNS	if (!mustBeXML && isXMLNS
&& (len > xmlnsLen \|\| uri[len] != xmlnsNamespace[len]))	&& (len > xmlnsLen \|\| uri[len] != xmlnsNamespace[len]))
isXMLNS = XML_FALSE;	isXMLNS = XML_FALSE;
}	}
Line 3207 ignoreSectionProcessor(XML_Parser parser,	Line 3311 ignoreSectionProcessor(XML_Parser parser,
const char *end,	const char *end,
const char **endPtr)	const char **endPtr)
{	{
enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,	enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
endPtr, (XML_Bool)!ps_finalBuffer);	endPtr, (XML_Bool)!ps_finalBuffer);
if (result != XML_ERROR_NONE)	if (result != XML_ERROR_NONE)
return result;	return result;
Line 3489 entityValueInitProcessor(XML_Parser parser,	Line 3593 entityValueInitProcessor(XML_Parser parser,
const char *next = start;	const char *next = start;
eventPtr = start;	eventPtr = start;

for (;;) {	for (;;) {
tok = XmlPrologTok(encoding, start, end, &next);	tok = XmlPrologTok(encoding, start, end, &next);
eventEndPtr = next;	eventEndPtr = next;
if (tok <= 0) {	if (tok <= 0) {
Line 3517 entityValueInitProcessor(XML_Parser parser,	Line 3621 entityValueInitProcessor(XML_Parser parser,
if (result != XML_ERROR_NONE)	if (result != XML_ERROR_NONE)
return result;	return result;
switch (ps_parsing) {	switch (ps_parsing) {
case XML_SUSPENDED:	case XML_SUSPENDED:
*nextPtr = next;	*nextPtr = next;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_FINISHED:	case XML_FINISHED:
Line 3582 externalParEntProcessor(XML_Parser parser,	Line 3686 externalParEntProcessor(XML_Parser parser,
}	}

processor = prologProcessor;	processor = prologProcessor;
return doProlog(parser, encoding, s, end, tok, next,	return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!ps_finalBuffer);	nextPtr, (XML_Bool)!ps_finalBuffer);
}	}

Line 3632 prologProcessor(XML_Parser parser,	Line 3736 prologProcessor(XML_Parser parser,
{	{
const char *next = s;	const char *next = s;
int tok = XmlPrologTok(encoding, s, end, &next);	int tok = XmlPrologTok(encoding, s, end, &next);
return doProlog(parser, encoding, s, end, tok, next,	return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!ps_finalBuffer);	nextPtr, (XML_Bool)!ps_finalBuffer);
}	}

Line 3649 doProlog(XML_Parser parser,	Line 3753 doProlog(XML_Parser parser,
#ifdef XML_DTD	#ifdef XML_DTD
static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };	static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
#endif /* XML_DTD */	#endif /* XML_DTD */
static const XML_Char atypeCDATA[] =	static const XML_Char atypeCDATA[] =
{ ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };	{ ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };	static const XML_Char atypeID[] = { ASCII_I, ASCII_D, '\0' };
static const XML_Char atypeIDREF[] =	static const XML_Char atypeIDREF[] =
Line 3670 doProlog(XML_Parser parser,	Line 3774 doProlog(XML_Parser parser,
static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };	static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };

/* save one level of indirection */	/* save one level of indirection */
DTD * const dtd = _dtd;	DTD * const dtd = _dtd;

const char **eventPP;	const char **eventPP;
const char **eventEndPP;	const char **eventEndPP;
Line 3777 doProlog(XML_Parser parser,	Line 3881 doProlog(XML_Parser parser,
case XML_ROLE_DOCTYPE_PUBLIC_ID:	case XML_ROLE_DOCTYPE_PUBLIC_ID:
#ifdef XML_DTD	#ifdef XML_DTD
useForeignDTD = XML_FALSE;	useForeignDTD = XML_FALSE;
declEntity = (ENTITY *)lookup(&dtd->paramEntities,	declEntity = (ENTITY *)lookup(parser,
	&dtd->paramEntities,
externalSubsetName,	externalSubsetName,
sizeof(ENTITY));	sizeof(ENTITY));
if (!declEntity)	if (!declEntity)
Line 3785 doProlog(XML_Parser parser,	Line 3890 doProlog(XML_Parser parser,
#endif /* XML_DTD */	#endif /* XML_DTD */
dtd->hasParamEntityRefs = XML_TRUE;	dtd->hasParamEntityRefs = XML_TRUE;
if (startDoctypeDeclHandler) {	if (startDoctypeDeclHandler) {
	XML_Char *pubId;
if (!XmlIsPublicId(enc, s, next, eventPP))	if (!XmlIsPublicId(enc, s, next, eventPP))
return XML_ERROR_PUBLICID;	return XML_ERROR_PUBLICID;
doctypePubid = poolStoreString(&tempPool, enc,	pubId = poolStoreString(&tempPool, enc,
s + enc->minBytesPerChar,	s + enc->minBytesPerChar,
next - enc->minBytesPerChar);	next - enc->minBytesPerChar);
if (!doctypePubid)	if (!pubId)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
normalizePublicId((XML_Char *)doctypePubid);	normalizePublicId(pubId);
poolFinish(&tempPool);	poolFinish(&tempPool);
	doctypePubid = pubId;
handleDefault = XML_FALSE;	handleDefault = XML_FALSE;
goto alreadyChecked;	goto alreadyChecked;
}	}
Line 3832 doProlog(XML_Parser parser,	Line 3939 doProlog(XML_Parser parser,
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;	XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE;	dtd->hasParamEntityRefs = XML_TRUE;
if (paramEntityParsing && externalEntityRefHandler) {	if (paramEntityParsing && externalEntityRefHandler) {
ENTITY entity = (ENTITY )lookup(&dtd->paramEntities,	ENTITY entity = (ENTITY )lookup(parser,
	&dtd->paramEntities,
externalSubsetName,	externalSubsetName,
sizeof(ENTITY));	sizeof(ENTITY));
if (!entity)	if (!entity)
Line 3847 doProlog(XML_Parser parser,	Line 3955 doProlog(XML_Parser parser,
entity->publicId))	entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING;	return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead) {	if (dtd->paramEntityRead) {
if (!dtd->standalone &&	if (!dtd->standalone &&
notStandaloneHandler &&	notStandaloneHandler &&
!notStandaloneHandler(handlerArg))	!notStandaloneHandler(handlerArg))
return XML_ERROR_NOT_STANDALONE;	return XML_ERROR_NOT_STANDALONE;
}	}
Line 3876 doProlog(XML_Parser parser,	Line 3984 doProlog(XML_Parser parser,
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;	XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE;	dtd->hasParamEntityRefs = XML_TRUE;
if (paramEntityParsing && externalEntityRefHandler) {	if (paramEntityParsing && externalEntityRefHandler) {
ENTITY entity = (ENTITY )lookup(&dtd->paramEntities,	ENTITY entity = (ENTITY )lookup(parser, &dtd->paramEntities,
externalSubsetName,	externalSubsetName,
sizeof(ENTITY));	sizeof(ENTITY));
if (!entity)	if (!entity)
Line 4090 doProlog(XML_Parser parser,	Line 4198 doProlog(XML_Parser parser,
break;	break;
#else /* XML_DTD */	#else /* XML_DTD */
if (!declEntity) {	if (!declEntity) {
declEntity = (ENTITY *)lookup(&dtd->paramEntities,	declEntity = (ENTITY *)lookup(parser,
	&dtd->paramEntities,
externalSubsetName,	externalSubsetName,
sizeof(ENTITY));	sizeof(ENTITY));
if (!declEntity)	if (!declEntity)
Line 4165 doProlog(XML_Parser parser,	Line 4274 doProlog(XML_Parser parser,
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);	const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
declEntity = (ENTITY *)lookup(&dtd->generalEntities, name,	declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, name,
sizeof(ENTITY));	sizeof(ENTITY));
if (!declEntity)	if (!declEntity)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
Line 4197 doProlog(XML_Parser parser,	Line 4306 doProlog(XML_Parser parser,
const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);	const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
declEntity = (ENTITY *)lookup(&dtd->paramEntities,	declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
name, sizeof(ENTITY));	name, sizeof(ENTITY));
if (!declEntity)	if (!declEntity)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
Line 4286 doProlog(XML_Parser parser,	Line 4395 doProlog(XML_Parser parser,
switch (tok) {	switch (tok) {
case XML_TOK_PARAM_ENTITY_REF:	case XML_TOK_PARAM_ENTITY_REF:
/* PE references in internal subset are	/* PE references in internal subset are
not allowed within declarations. */	not allowed within declarations. */
return XML_ERROR_PARAM_ENTITY_REF;	return XML_ERROR_PARAM_ENTITY_REF;
case XML_TOK_XML_DECL:	case XML_TOK_XML_DECL:
return XML_ERROR_MISPLACED_XML_PI;	return XML_ERROR_MISPLACED_XML_PI;
Line 4379 doProlog(XML_Parser parser,	Line 4488 doProlog(XML_Parser parser,
next - enc->minBytesPerChar);	next - enc->minBytesPerChar);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);	entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
poolDiscard(&dtd->pool);	poolDiscard(&dtd->pool);
/* first, determine if a check for an existing declaration is needed;	/* first, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal,	if yes, check that the entity exists, and that it is internal,
Line 4407 doProlog(XML_Parser parser,	Line 4516 doProlog(XML_Parser parser,
return XML_ERROR_RECURSIVE_ENTITY_REF;	return XML_ERROR_RECURSIVE_ENTITY_REF;
if (entity->textPtr) {	if (entity->textPtr) {
enum XML_Error result;	enum XML_Error result;
XML_Bool betweenDecl =	XML_Bool betweenDecl =
(role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);	(role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
result = processInternalEntity(parser, entity, betweenDecl);	result = processInternalEntity(parser, entity, betweenDecl);
if (result != XML_ERROR_NONE)	if (result != XML_ERROR_NONE)
Line 4602 doProlog(XML_Parser parser,	Line 4711 doProlog(XML_Parser parser,
reportDefault(parser, enc, s, next);	reportDefault(parser, enc, s, next);

switch (ps_parsing) {	switch (ps_parsing) {
case XML_SUSPENDED:	case XML_SUSPENDED:
*nextPtr = next;	*nextPtr = next;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_FINISHED:	case XML_FINISHED:
Line 4672 epilogProcessor(XML_Parser parser,	Line 4781 epilogProcessor(XML_Parser parser,
}	}
eventPtr = s = next;	eventPtr = s = next;
switch (ps_parsing) {	switch (ps_parsing) {
case XML_SUSPENDED:	case XML_SUSPENDED:
*nextPtr = next;	*nextPtr = next;
return XML_ERROR_NONE;	return XML_ERROR_NONE;
case XML_FINISHED:	case XML_FINISHED:
Line 4715 processInternalEntity(XML_Parser parser, ENTITY *entit	Line 4824 processInternalEntity(XML_Parser parser, ENTITY *entit
#ifdef XML_DTD	#ifdef XML_DTD
if (entity->is_param) {	if (entity->is_param) {
int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);	int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,	result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
next, &next, XML_FALSE);	next, &next, XML_FALSE);
}	}
else	else
#endif /* XML_DTD */	#endif /* XML_DTD */
result = doContent(parser, tagLevel, internalEncoding, textStart,	result = doContent(parser, tagLevel, internalEncoding, textStart,
textEnd, &next, XML_FALSE);	textEnd, &next, XML_FALSE);

if (result == XML_ERROR_NONE) {	if (result == XML_ERROR_NONE) {
Line 4760 internalEntityProcessor(XML_Parser parser,	Line 4869 internalEntityProcessor(XML_Parser parser,
#ifdef XML_DTD	#ifdef XML_DTD
if (entity->is_param) {	if (entity->is_param) {
int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);	int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
result = doProlog(parser, internalEncoding, textStart, textEnd, tok,	result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
next, &next, XML_FALSE);	next, &next, XML_FALSE);
}	}
else	else
#endif /* XML_DTD */	#endif /* XML_DTD */
result = doContent(parser, openEntity->startTagLevel, internalEncoding,	result = doContent(parser, openEntity->startTagLevel, internalEncoding,
textStart, textEnd, &next, XML_FALSE);	textStart, textEnd, &next, XML_FALSE);

if (result != XML_ERROR_NONE)	if (result != XML_ERROR_NONE)
return result;	return result;
Line 4787 internalEntityProcessor(XML_Parser parser,	Line 4896 internalEntityProcessor(XML_Parser parser,
int tok;	int tok;
processor = prologProcessor;	processor = prologProcessor;
tok = XmlPrologTok(encoding, s, end, &next);	tok = XmlPrologTok(encoding, s, end, &next);
return doProlog(parser, encoding, s, end, tok, next, nextPtr,	return doProlog(parser, encoding, s, end, tok, next, nextPtr,
(XML_Bool)!ps_finalBuffer);	(XML_Bool)!ps_finalBuffer);
}	}
else	else
Line 4796 internalEntityProcessor(XML_Parser parser,	Line 4905 internalEntityProcessor(XML_Parser parser,
processor = contentProcessor;	processor = contentProcessor;
/* see externalEntityContentProcessor vs contentProcessor */	/* see externalEntityContentProcessor vs contentProcessor */
return doContent(parser, parentParser ? 1 : 0, encoding, s, end,	return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
nextPtr, (XML_Bool)!ps_finalBuffer);	nextPtr, (XML_Bool)!ps_finalBuffer);
}	}
}	}

static enum XML_Error PTRCALL	static enum XML_Error PTRCALL
Line 4903 appendAttributeValue(XML_Parser parser, const ENCODING	Line 5012 appendAttributeValue(XML_Parser parser, const ENCODING
next - enc->minBytesPerChar);	next - enc->minBytesPerChar);
if (!name)	if (!name)
return XML_ERROR_NO_MEMORY;	return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);	entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
poolDiscard(&temp2Pool);	poolDiscard(&temp2Pool);
/* First, determine if a check for an existing declaration is needed;	/* First, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal.	if yes, check that the entity exists, and that it is internal.
Line 4950 appendAttributeValue(XML_Parser parser, const ENCODING	Line 5059 appendAttributeValue(XML_Parser parser, const ENCODING
if (!entity->textPtr) {	if (!entity->textPtr) {
if (enc == encoding)	if (enc == encoding)
eventPtr = ptr;	eventPtr = ptr;
return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;	return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
}	}
else {	else {
enum XML_Error result;	enum XML_Error result;
Line 5012 storeEntityValue(XML_Parser parser,	Line 5121 storeEntityValue(XML_Parser parser,
result = XML_ERROR_NO_MEMORY;	result = XML_ERROR_NO_MEMORY;
goto endEntityValue;	goto endEntityValue;
}	}
entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);	entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
poolDiscard(&tempPool);	poolDiscard(&tempPool);
if (!entity) {	if (!entity) {
/* not a well-formedness error - see XML 1.0: WFC Entity Declared */	/* not a well-formedness error - see XML 1.0: WFC Entity Declared */
Line 5302 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *	Line 5411 setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *
}	}
if (!poolAppendChar(&dtd->pool, XML_T('\0')))	if (!poolAppendChar(&dtd->pool, XML_T('\0')))
return 0;	return 0;
prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),	prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
sizeof(PREFIX));	sizeof(PREFIX));
if (!prefix)	if (!prefix)
return 0;	return 0;
Line 5331 getAttributeId(XML_Parser parser, const ENCODING *enc,	Line 5440 getAttributeId(XML_Parser parser, const ENCODING *enc,
return NULL;	return NULL;
/* skip quotation mark - its storage will be re-used (like in name[-1]) */	/* skip quotation mark - its storage will be re-used (like in name[-1]) */
++name;	++name;
id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));	id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
if (!id)	if (!id)
return NULL;	return NULL;
if (id->name != name)	if (id->name != name)
Line 5349 getAttributeId(XML_Parser parser, const ENCODING *enc,	Line 5458 getAttributeId(XML_Parser parser, const ENCODING *enc,
if (name[5] == XML_T('\0'))	if (name[5] == XML_T('\0'))
id->prefix = &dtd->defaultPrefix;	id->prefix = &dtd->defaultPrefix;
else	else
id->prefix = (PREFIX *)lookup(&dtd->prefixes, name + 6, sizeof(PREFIX));	id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
id->xmlns = XML_TRUE;	id->xmlns = XML_TRUE;
}	}
else {	else {
Line 5364 getAttributeId(XML_Parser parser, const ENCODING *enc,	Line 5473 getAttributeId(XML_Parser parser, const ENCODING *enc,
}	}
if (!poolAppendChar(&dtd->pool, XML_T('\0')))	if (!poolAppendChar(&dtd->pool, XML_T('\0')))
return NULL;	return NULL;
id->prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&dtd->pool),	id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
sizeof(PREFIX));	sizeof(PREFIX));
if (id->prefix->name == poolStart(&dtd->pool))	if (id->prefix->name == poolStart(&dtd->pool))
poolFinish(&dtd->pool);	poolFinish(&dtd->pool);
Line 5460 setContext(XML_Parser parser, const XML_Char *context)	Line 5569 setContext(XML_Parser parser, const XML_Char *context)
ENTITY *e;	ENTITY *e;
if (!poolAppendChar(&tempPool, XML_T('\0')))	if (!poolAppendChar(&tempPool, XML_T('\0')))
return XML_FALSE;	return XML_FALSE;
e = (ENTITY *)lookup(&dtd->generalEntities, poolStart(&tempPool), 0);	e = (ENTITY *)lookup(parser, &dtd->generalEntities, poolStart(&tempPool), 0);
if (e)	if (e)
e->open = XML_TRUE;	e->open = XML_TRUE;
if (*s != XML_T('\0'))	if (*s != XML_T('\0'))
Line 5475 setContext(XML_Parser parser, const XML_Char *context)	Line 5584 setContext(XML_Parser parser, const XML_Char *context)
else {	else {
if (!poolAppendChar(&tempPool, XML_T('\0')))	if (!poolAppendChar(&tempPool, XML_T('\0')))
return XML_FALSE;	return XML_FALSE;
prefix = (PREFIX *)lookup(&dtd->prefixes, poolStart(&tempPool),	prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&tempPool),
sizeof(PREFIX));	sizeof(PREFIX));
if (!prefix)	if (!prefix)
return XML_FALSE;	return XML_FALSE;
Line 5639 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Mem	Line 5748 dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Mem
The new DTD has already been initialized.	The new DTD has already been initialized.
*/	*/
static int	static int
dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memory_Handling_Suite *ms)	dtdCopy(XML_Parser oldParser, DTD newDtd, const DTD oldDtd, const XML_Memory_Handling_Suite *ms)
{	{
HASH_TABLE_ITER iter;	HASH_TABLE_ITER iter;

Line 5654 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5763 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
name = poolCopyString(&(newDtd->pool), oldP->name);	name = poolCopyString(&(newDtd->pool), oldP->name);
if (!name)	if (!name)
return 0;	return 0;
if (!lookup(&(newDtd->prefixes), name, sizeof(PREFIX)))	if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
return 0;	return 0;
}	}

Line 5676 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5785 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
if (!name)	if (!name)
return 0;	return 0;
++name;	++name;
newA = (ATTRIBUTE_ID *)lookup(&(newDtd->attributeIds), name,	newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
sizeof(ATTRIBUTE_ID));	sizeof(ATTRIBUTE_ID));
if (!newA)	if (!newA)
return 0;	return 0;
Line 5686 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5795 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
if (oldA->prefix == &oldDtd->defaultPrefix)	if (oldA->prefix == &oldDtd->defaultPrefix)
newA->prefix = &newDtd->defaultPrefix;	newA->prefix = &newDtd->defaultPrefix;
else	else
newA->prefix = (PREFIX *)lookup(&(newDtd->prefixes),	newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
oldA->prefix->name, 0);	oldA->prefix->name, 0);
}	}
}	}
Line 5705 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5814 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
name = poolCopyString(&(newDtd->pool), oldE->name);	name = poolCopyString(&(newDtd->pool), oldE->name);
if (!name)	if (!name)
return 0;	return 0;
newE = (ELEMENT_TYPE *)lookup(&(newDtd->elementTypes), name,	newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
sizeof(ELEMENT_TYPE));	sizeof(ELEMENT_TYPE));
if (!newE)	if (!newE)
return 0;	return 0;
Line 5719 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5828 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
}	}
if (oldE->idAtt)	if (oldE->idAtt)
newE->idAtt = (ATTRIBUTE_ID *)	newE->idAtt = (ATTRIBUTE_ID *)
lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);	lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0);
newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;	newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
if (oldE->prefix)	if (oldE->prefix)
newE->prefix = (PREFIX *)lookup(&(newDtd->prefixes),	newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
oldE->prefix->name, 0);	oldE->prefix->name, 0);
for (i = 0; i < newE->nDefaultAtts; i++) {	for (i = 0; i < newE->nDefaultAtts; i++) {
newE->defaultAtts[i].id = (ATTRIBUTE_ID *)	newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);	lookup(oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;	newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
if (oldE->defaultAtts[i].value) {	if (oldE->defaultAtts[i].value) {
newE->defaultAtts[i].value	newE->defaultAtts[i].value
Line 5740 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5849 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
}	}

/* Copy the entity tables. */	/* Copy the entity tables. */
if (!copyEntityTable(&(newDtd->generalEntities),	if (!copyEntityTable(oldParser,
	&(newDtd->generalEntities),
&(newDtd->pool),	&(newDtd->pool),
&(oldDtd->generalEntities)))	&(oldDtd->generalEntities)))
return 0;	return 0;

#ifdef XML_DTD	#ifdef XML_DTD
if (!copyEntityTable(&(newDtd->paramEntities),	if (!copyEntityTable(oldParser,
	&(newDtd->paramEntities),
&(newDtd->pool),	&(newDtd->pool),
&(oldDtd->paramEntities)))	&(oldDtd->paramEntities)))
return 0;	return 0;
Line 5769 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo	Line 5880 dtdCopy(DTD newDtd, const DTD oldDtd, const XML_Memo
} /* End dtdCopy */	} /* End dtdCopy */

static int	static int
copyEntityTable(HASH_TABLE *newTable,	copyEntityTable(XML_Parser oldParser,
	HASH_TABLE *newTable,
STRING_POOL *newPool,	STRING_POOL *newPool,
const HASH_TABLE *oldTable)	const HASH_TABLE *oldTable)
{	{
Line 5788 copyEntityTable(HASH_TABLE *newTable,	Line 5900 copyEntityTable(HASH_TABLE *newTable,
name = poolCopyString(newPool, oldE->name);	name = poolCopyString(newPool, oldE->name);
if (!name)	if (!name)
return 0;	return 0;
newE = (ENTITY *)lookup(newTable, name, sizeof(ENTITY));	newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
if (!newE)	if (!newE)
return 0;	return 0;
if (oldE->systemId) {	if (oldE->systemId) {
Line 5846 keyeq(KEY s1, KEY s2)	Line 5958 keyeq(KEY s1, KEY s2)
}	}

static unsigned long FASTCALL	static unsigned long FASTCALL
hash(KEY s)	hash(XML_Parser parser, KEY s)
{	{
unsigned long h = 0;	unsigned long h = hash_secret_salt;
while (*s)	while (*s)
h = CHAR_HASH(h, *s++);	h = CHAR_HASH(h, *s++);
return h;	return h;
}	}

static NAMED *	static NAMED *
lookup(HASH_TABLE *table, KEY name, size_t createSize)	lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize)
{	{
size_t i;	size_t i;
if (table->size == 0) {	if (table->size == 0) {
Line 5872 lookup(HASH_TABLE *table, KEY name, size_t createSize)	Line 5984 lookup(HASH_TABLE *table, KEY name, size_t createSize)
return NULL;	return NULL;
}	}
memset(table->v, 0, tsize);	memset(table->v, 0, tsize);
i = hash(name) & ((unsigned long)table->size - 1);	i = hash(parser, name) & ((unsigned long)table->size - 1);
}	}
else {	else {
unsigned long h = hash(name);	unsigned long h = hash(parser, name);
unsigned long mask = (unsigned long)table->size - 1;	unsigned long mask = (unsigned long)table->size - 1;
unsigned char step = 0;	unsigned char step = 0;
i = h & mask;	i = h & mask;
Line 5901 lookup(HASH_TABLE *table, KEY name, size_t createSize)	Line 6013 lookup(HASH_TABLE *table, KEY name, size_t createSize)
memset(newV, 0, tsize);	memset(newV, 0, tsize);
for (i = 0; i < table->size; i++)	for (i = 0; i < table->size; i++)
if (table->v[i]) {	if (table->v[i]) {
unsigned long newHash = hash(table->v[i]->name);	unsigned long newHash = hash(parser, table->v[i]->name);
size_t j = newHash & newMask;	size_t j = newHash & newMask;
step = 0;	step = 0;
while (newV[j]) {	while (newV[j]) {
Line 6122 poolGrow(STRING_POOL *pool)	Line 6234 poolGrow(STRING_POOL *pool)
}	}
if (pool->blocks && pool->start == pool->blocks->s) {	if (pool->blocks && pool->start == pool->blocks->s) {
int blockSize = (int)(pool->end - pool->start)*2;	int blockSize = (int)(pool->end - pool->start)*2;
pool->blocks = (BLOCK *)	BLOCK temp = (BLOCK )
pool->mem->realloc_fcn(pool->blocks,	pool->mem->realloc_fcn(pool->blocks,
(offsetof(BLOCK, s)	(offsetof(BLOCK, s)
+ blockSize * sizeof(XML_Char)));	+ blockSize * sizeof(XML_Char)));
if (pool->blocks == NULL)	if (temp == NULL)
return XML_FALSE;	return XML_FALSE;
	pool->blocks = temp;
pool->blocks->size = blockSize;	pool->blocks->size = blockSize;
pool->ptr = pool->blocks->s + (pool->ptr - pool->start);	pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
pool->start = pool->blocks->s;	pool->start = pool->blocks->s;
Line 6276 getElementType(XML_Parser parser,	Line 6389 getElementType(XML_Parser parser,

if (!name)	if (!name)
return NULL;	return NULL;
ret = (ELEMENT_TYPE *) lookup(&dtd->elementTypes, name, sizeof(ELEMENT_TYPE));	ret = (ELEMENT_TYPE *) lookup(parser, &dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
if (!ret)	if (!ret)
return NULL;	return NULL;
if (ret->name != name)	if (ret->name != name)

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.1.1.1.2.1
changed lines
	Added in v.1.1.1.2