#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <time.h>
#include "ascii.h"
#include "expat.h"
#include "internal.h"
#include "xmltok.h"
#include "xmlrole.h"

Data Structures
struct	attribute_id

struct	binding

struct	block

struct	CONTENT_SCAFFOLD

struct	DEFAULT_ATTRIBUTE

struct	DTD

struct	ELEMENT_TYPE

struct	ENTITY

struct	HASH_TABLE

struct	HASH_TABLE_ITER

struct	NAMED

struct	NS_ATT

struct	open_internal_entity

struct	prefix

struct	STRING_POOL

struct	tag

struct	TAG_NAME

struct	XML_ParserStruct

Macros
#define	_dtd (parser->m_dtd)

#define	attInfo (parser->m_attInfo)

#define	attlistDeclHandler (parser->m_attlistDeclHandler)

#define	atts (parser->m_atts)

#define	attsSize (parser->m_attsSize)

#define	buffer (parser->m_buffer)

#define	bufferEnd (parser->m_bufferEnd)

#define	bufferLim (parser->m_bufferLim)

#define	bufferPtr (parser->m_bufferPtr)

#define	CHAR_HASH(h, c) (((h) * 0xF4243) ^ (unsigned char)(c))

#define	characterDataHandler (parser->m_characterDataHandler)

#define	commentHandler (parser->m_commentHandler)

#define	CONTEXT_SEP XML_T(ASCII_FF)

#define	curBase (parser->m_curBase)

#define	dataBuf (parser->m_dataBuf)

#define	dataBufEnd (parser->m_dataBufEnd)

#define	declAttributeId (parser->m_declAttributeId)

#define	declAttributeIsCdata (parser->m_declAttributeIsCdata)

#define	declAttributeIsId (parser->m_declAttributeIsId)

#define	declAttributeType (parser->m_declAttributeType)

#define	declElementType (parser->m_declElementType)

#define	declEntity (parser->m_declEntity)

#define	declNotationName (parser->m_declNotationName)

#define	declNotationPublicId (parser->m_declNotationPublicId)

#define	defaultExpandInternalEntities (parser->m_defaultExpandInternalEntities)

#define	defaultHandler (parser->m_defaultHandler)

#define	doctypeName (parser->m_doctypeName)

#define	doctypePubid (parser->m_doctypePubid)

#define	doctypeSysid (parser->m_doctypeSysid)

#define	elementDeclHandler (parser->m_elementDeclHandler)

#define	encoding (parser->m_encoding)

#define	endCdataSectionHandler (parser->m_endCdataSectionHandler)

#define	endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

#define	endElementHandler (parser->m_endElementHandler)

#define	endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

#define	entityDeclHandler (parser->m_entityDeclHandler)

#define	errorCode (parser->m_errorCode)

#define	eventEndPtr (parser->m_eventEndPtr)

#define	eventPtr (parser->m_eventPtr)

#define	EXPAND_SPARE 24

#define	externalEntityRefHandler (parser->m_externalEntityRefHandler)

#define	externalEntityRefHandlerArg (parser->m_externalEntityRefHandlerArg)

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

#define	freeBindingList (parser->m_freeBindingList)

#define	freeInternalEntities (parser->m_freeInternalEntities)

#define	freeTagList (parser->m_freeTagList)

#define	groupConnector (parser->m_groupConnector)

#define	groupSize (parser->m_groupSize)

#define	handlerArg (parser->m_handlerArg)

#define	hash_secret_salt (parser->m_hash_secret_salt)

#define	idAttIndex (parser->m_idAttIndex)

#define	inheritedBindings (parser->m_inheritedBindings)

#define	INIT_ATTS_SIZE 16

#define	INIT_ATTS_VERSION 0xFFFFFFFF

#define	INIT_BLOCK_SIZE 1024

#define	INIT_BUFFER_SIZE 1024

#define	INIT_DATA_BUF_SIZE 1024

#define	INIT_POWER 6

#define	INIT_SCAFFOLD_ELEMENTS 32

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

#define	initEncoding (parser->m_initEncoding)

#define	internalEncoding (parser->m_internalEncoding)

#define	internalEntityRefHandler (parser->m_internalEntityRefHandler)

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

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

#define	namespaceSeparator (parser->m_namespaceSeparator)

#define	notationDeclHandler (parser->m_notationDeclHandler)

#define	notStandaloneHandler (parser->m_notStandaloneHandler)

#define	ns (parser->m_ns)

#define	ns_triplets (parser->m_ns_triplets)

#define	nsAtts (parser->m_nsAtts)

#define	nsAttsPower (parser->m_nsAttsPower)

#define	nsAttsVersion (parser->m_nsAttsVersion)

#define	nSpecifiedAtts (parser->m_nSpecifiedAtts)

#define	openInternalEntities (parser->m_openInternalEntities)

#define	parentParser (parser->m_parentParser)

#define	parseEndByteIndex (parser->m_parseEndByteIndex)

#define	parseEndPtr (parser->m_parseEndPtr)

#define	poolAppendChar(pool, c)

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

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

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

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

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

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

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

#define	position (parser->m_position)

#define	positionPtr (parser->m_positionPtr)

#define	PROBE_STEP(hash, mask, power) ((unsigned char)((SECOND_HASH(hash, mask, power)) \| 1))

#define	processingInstructionHandler (parser->m_processingInstructionHandler)

#define	processor (parser->m_processor)

#define	prologState (parser->m_prologState)

#define	protocolEncodingName (parser->m_protocolEncodingName)

#define	ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

#define	ps_parsing (parser->m_parsingStatus.parsing)

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

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

#define	SECOND_HASH(hash, mask, power) ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

#define	skippedEntityHandler (parser->m_skippedEntityHandler)

#define	startCdataSectionHandler (parser->m_startCdataSectionHandler)

#define	startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

#define	startElementHandler (parser->m_startElementHandler)

#define	startNamespaceDeclHandler (parser->m_startNamespaceDeclHandler)

#define	tagLevel (parser->m_tagLevel)

#define	tagStack (parser->m_tagStack)

#define	temp2Pool (parser->m_temp2Pool)

#define	tempPool (parser->m_tempPool)

#define	unknownEncodingData (parser->m_unknownEncodingData)

#define	unknownEncodingHandler (parser->m_unknownEncodingHandler)

#define	unknownEncodingHandlerData (parser->m_unknownEncodingHandlerData)

#define	unknownEncodingMem (parser->m_unknownEncodingMem)

#define	unknownEncodingRelease (parser->m_unknownEncodingRelease)

#define	unparsedEntityDeclHandler (parser->m_unparsedEntityDeclHandler)

#define	userData (parser->m_userData)

#define	V1(a, b, c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)

#define	V2(a, b, c) XML_L("expat_")V1(a,b,c)

#define	XML_BUILDING_EXPAT 1

#define	XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

#define	XML_L(x) x

#define	XML_T(x) x

#define	XmlConvert XmlUtf8Convert

#define	xmlDeclHandler (parser->m_xmlDeclHandler)

#define	XmlEncode XmlUtf8Encode

#define	XmlGetInternalEncoding XmlGetUtf8InternalEncoding

#define	XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

#define	XmlGetInternalEncodingNS XmlGetInternalEncoding

#define	XmlInitEncodingNS XmlInitEncoding

#define	XmlInitUnknownEncodingNS XmlInitUnknownEncoding

#define	XmlParseXmlDeclNS XmlParseXmlDecl

Typedefs
typedef struct attribute_id	ATTRIBUTE_ID

typedef struct binding	BINDING

typedef struct block	BLOCK

typedef char	ICHAR

typedef const XML_Char *	KEY

typedef struct open_internal_entity	OPEN_INTERNAL_ENTITY

typedef struct prefix	PREFIX

typedef struct tag	TAG

Functions
static enum XML_Error	addBinding (XML_Parser parser, PREFIX prefix, const ATTRIBUTE_ID attId, const XML_Char uri, BINDING *bindingsPtr)

static enum XML_Error	appendAttributeValue (XML_Parser parser, const ENCODING , XML_Bool isCdata, const char , const char , STRING_POOL )

static XML_Content *	build_model (XML_Parser parser)

static void	build_node (XML_Parser parser, int src_node, XML_Content dest, XML_Content contpos, XML_Char *strpos)

static enum XML_Error PTRCALL	cdataSectionProcessor (XML_Parser parser, const char start, const char end, const char **endPtr)

static enum XML_Error PTRCALL	contentProcessor (XML_Parser parser, const char start, const char end, const char **endPtr)

static int	copyEntityTable (XML_Parser oldParser, HASH_TABLE , STRING_POOL , const HASH_TABLE *)

static int	defineAttribute (ELEMENT_TYPE type, ATTRIBUTE_ID , XML_Bool isCdata, XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser)

static void FASTCALL	destroyBindings (BINDING *bindings, XML_Parser parser)

static enum XML_Error	doCdataSection (XML_Parser parser, const ENCODING , const char startPtr, const char end, const char **nextPtr, XML_Bool haveMore)

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	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 int	dtdCopy (XML_Parser oldParser, DTD newDtd, const DTD oldDtd, const XML_Memory_Handling_Suite *ms)

static DTD *	dtdCreate (const XML_Memory_Handling_Suite *ms)

static void	dtdDestroy (DTD p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite ms)

static void	dtdReset (DTD p, const XML_Memory_Handling_Suite ms)

static enum XML_Error PTRCALL	epilogProcessor (XML_Parser parser, const char s, const char end, const char **nextPtr)

static enum XML_Error PTRCALL	errorProcessor (XML_Parser parser, const char s, const char end, const char **nextPtr)

static enum XML_Error PTRCALL	externalEntityContentProcessor (XML_Parser parser, const char start, const char end, const char **endPtr)

static enum XML_Error PTRCALL	externalEntityInitProcessor (XML_Parser parser, const char start, const char end, const char **endPtr)

static enum XML_Error PTRCALL	externalEntityInitProcessor2 (XML_Parser parser, const char start, const char end, const char **endPtr)

static enum XML_Error PTRCALL	externalEntityInitProcessor3 (XML_Parser parser, const char start, const char end, const char **endPtr)

static unsigned long	generate_hash_secret_salt (void)

static ATTRIBUTE_ID *	getAttributeId (XML_Parser parser, const ENCODING enc, const char start, const char *end)

static const XML_Char *	getContext (XML_Parser parser)

static ELEMENT_TYPE *	getElementType (XML_Parser parser, const ENCODING enc, const char ptr, const char *end)

static enum XML_Error	handleUnknownEncoding (XML_Parser parser, const XML_Char *encodingName)

static unsigned long FASTCALL	hash (XML_Parser parser, KEY s)

static void FASTCALL	hashTableClear (HASH_TABLE *)

static void FASTCALL	hashTableDestroy (HASH_TABLE *)

static void FASTCALL	hashTableInit (HASH_TABLE , const XML_Memory_Handling_Suite ms)

static void FASTCALL	hashTableIterInit (HASH_TABLE_ITER , const HASH_TABLE )

static NAMED *FASTCALL	hashTableIterNext (HASH_TABLE_ITER *)

static enum XML_Error	initializeEncoding (XML_Parser parser)

static enum XML_Error PTRCALL	internalEntityProcessor (XML_Parser parser, const char s, const char end, const char **nextPtr)

static XML_Bool FASTCALL	keyeq (KEY s1, KEY s2)

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

static void FASTCALL	moveToFreeBindingList (XML_Parser parser, BINDING *bindings)

static int FASTCALL	nextScaffoldPart (XML_Parser parser)

static void FASTCALL	normalizeLines (XML_Char *s)

static void FASTCALL	normalizePublicId (XML_Char *s)

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)

static XML_Char *	poolAppend (STRING_POOL pool, const ENCODING enc, const char ptr, const char end)

static const XML_Char *FASTCALL	poolAppendString (STRING_POOL pool, const XML_Char s)

static void FASTCALL	poolClear (STRING_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 void FASTCALL	poolDestroy (STRING_POOL *)

static XML_Bool FASTCALL	poolGrow (STRING_POOL *pool)

static void FASTCALL	poolInit (STRING_POOL , const XML_Memory_Handling_Suite ms)

static XML_Char *	poolStoreString (STRING_POOL pool, const ENCODING enc, const char ptr, const char end)

static enum XML_Error	processInternalEntity (XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl)

enum XML_Error PTRCALL	Processor (XML_Parser parser, const char start, const char end, const char **endPtr)

static enum XML_Error	processXmlDecl (XML_Parser parser, int isGeneralTextEntity, const char s, const char next)

static enum XML_Error PTRCALL	prologInitProcessor (XML_Parser parser, const char s, const char end, const char **nextPtr)

static enum XML_Error PTRCALL	prologProcessor (XML_Parser parser, const char s, const char end, const char **nextPtr)

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 int	reportProcessingInstruction (XML_Parser parser, const ENCODING enc, const char start, const char *end)

static XML_Bool	setContext (XML_Parser parser, const XML_Char *context)

static int	setElementTypePrefix (XML_Parser parser, ELEMENT_TYPE *)

static XML_Bool	startParsing (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	storeAtts (XML_Parser parser, const ENCODING , const char s, TAG_NAME tagNamePtr, BINDING *bindingsPtr)

static enum XML_Error	storeEntityValue (XML_Parser parser, const ENCODING enc, const char start, const char *end)

static XML_Bool	storeRawNames (XML_Parser parser)

void XMLCALL	XML_DefaultCurrent (XML_Parser parser)

const XML_LChar *XMLCALL	XML_ErrorString (enum XML_Error code)

const XML_LChar *XMLCALL	XML_ExpatVersion (void)

XML_Expat_Version XMLCALL	XML_ExpatVersionInfo (void)

XML_Parser XMLCALL	XML_ExternalEntityParserCreate (XML_Parser oldParser, const XML_Char context, const XML_Char encodingName)

void XMLCALL	XML_FreeContentModel (XML_Parser parser, XML_Content *model)

const XML_Char *XMLCALL	XML_GetBase (XML_Parser parser)

void *XMLCALL	XML_GetBuffer (XML_Parser parser, int len)

int XMLCALL	XML_GetCurrentByteCount (XML_Parser parser)

XML_Index XMLCALL	XML_GetCurrentByteIndex (XML_Parser parser)

XML_Size XMLCALL	XML_GetCurrentColumnNumber (XML_Parser parser)

XML_Size XMLCALL	XML_GetCurrentLineNumber (XML_Parser parser)

enum XML_Error XMLCALL	XML_GetErrorCode (XML_Parser parser)

const XML_Feature *XMLCALL	XML_GetFeatureList (void)

int XMLCALL	XML_GetIdAttributeIndex (XML_Parser parser)

const char *XMLCALL	XML_GetInputContext (XML_Parser parser, int offset, int size)

void XMLCALL	XML_GetParsingStatus (XML_Parser parser, XML_ParsingStatus *status)

int XMLCALL	XML_GetSpecifiedAttributeCount (XML_Parser parser)

void XMLCALL	XML_MemFree (XML_Parser parser, void *ptr)

void *XMLCALL	XML_MemMalloc (XML_Parser parser, size_t size)

void *XMLCALL	XML_MemRealloc (XML_Parser parser, void *ptr, size_t size)

enum XML_Status XMLCALL	XML_Parse (XML_Parser parser, const char *s, int len, int isFinal)

enum XML_Status XMLCALL	XML_ParseBuffer (XML_Parser parser, int len, int isFinal)

XML_Parser XMLCALL	XML_ParserCreate (const XML_Char *encodingName)

XML_Parser XMLCALL	XML_ParserCreate_MM (const XML_Char encodingName, const XML_Memory_Handling_Suite memsuite, const XML_Char *nameSep)

XML_Parser XMLCALL	XML_ParserCreateNS (const XML_Char *encodingName, XML_Char nsSep)

void XMLCALL	XML_ParserFree (XML_Parser parser)

XML_Bool XMLCALL	XML_ParserReset (XML_Parser parser, const XML_Char *encodingName)

enum XML_Status XMLCALL	XML_ResumeParser (XML_Parser parser)

void XMLCALL	XML_SetAttlistDeclHandler (XML_Parser parser, XML_AttlistDeclHandler attdecl)

enum XML_Status XMLCALL	XML_SetBase (XML_Parser parser, const XML_Char *p)

void XMLCALL	XML_SetCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end)

void XMLCALL	XML_SetCharacterDataHandler (XML_Parser parser, XML_CharacterDataHandler handler)

void XMLCALL	XML_SetCommentHandler (XML_Parser parser, XML_CommentHandler handler)

void XMLCALL	XML_SetDefaultHandler (XML_Parser parser, XML_DefaultHandler handler)

void XMLCALL	XML_SetDefaultHandlerExpand (XML_Parser parser, XML_DefaultHandler handler)

void XMLCALL	XML_SetDoctypeDeclHandler (XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end)

void XMLCALL	XML_SetElementDeclHandler (XML_Parser parser, XML_ElementDeclHandler eldecl)

void XMLCALL	XML_SetElementHandler (XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)

enum XML_Status XMLCALL	XML_SetEncoding (XML_Parser parser, const XML_Char *encodingName)

void XMLCALL	XML_SetEndCdataSectionHandler (XML_Parser parser, XML_EndCdataSectionHandler end)

void XMLCALL	XML_SetEndDoctypeDeclHandler (XML_Parser parser, XML_EndDoctypeDeclHandler end)

void XMLCALL	XML_SetEndElementHandler (XML_Parser parser, XML_EndElementHandler end)

void XMLCALL	XML_SetEndNamespaceDeclHandler (XML_Parser parser, XML_EndNamespaceDeclHandler end)

void XMLCALL	XML_SetEntityDeclHandler (XML_Parser parser, XML_EntityDeclHandler handler)

void XMLCALL	XML_SetExternalEntityRefHandler (XML_Parser parser, XML_ExternalEntityRefHandler handler)

void XMLCALL	XML_SetExternalEntityRefHandlerArg (XML_Parser parser, void *arg)

int XMLCALL	XML_SetHashSalt (XML_Parser parser, unsigned long hash_salt)

void XMLCALL	XML_SetNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end)

void XMLCALL	XML_SetNotationDeclHandler (XML_Parser parser, XML_NotationDeclHandler handler)

void XMLCALL	XML_SetNotStandaloneHandler (XML_Parser parser, XML_NotStandaloneHandler handler)

int XMLCALL	XML_SetParamEntityParsing (XML_Parser parser, enum XML_ParamEntityParsing peParsing)

void XMLCALL	XML_SetProcessingInstructionHandler (XML_Parser parser, XML_ProcessingInstructionHandler handler)

void XMLCALL	XML_SetReturnNSTriplet (XML_Parser parser, int do_nst)

void XMLCALL	XML_SetSkippedEntityHandler (XML_Parser parser, XML_SkippedEntityHandler handler)

void XMLCALL	XML_SetStartCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start)

void XMLCALL	XML_SetStartDoctypeDeclHandler (XML_Parser parser, XML_StartDoctypeDeclHandler start)

void XMLCALL	XML_SetStartElementHandler (XML_Parser parser, XML_StartElementHandler start)

void XMLCALL	XML_SetStartNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start)

void XMLCALL	XML_SetUnknownEncodingHandler (XML_Parser parser, XML_UnknownEncodingHandler handler, void *data)

void XMLCALL	XML_SetUnparsedEntityDeclHandler (XML_Parser parser, XML_UnparsedEntityDeclHandler handler)

void XMLCALL	XML_SetUserData (XML_Parser parser, void *p)

void XMLCALL	XML_SetXmlDeclHandler (XML_Parser parser, XML_XmlDeclHandler handler)

enum XML_Status XMLCALL	XML_StopParser (XML_Parser parser, XML_Bool resumable)

enum XML_Error XMLCALL	XML_UseForeignDTD (XML_Parser parser, XML_Bool useDTD)

void XMLCALL	XML_UseParserAsHandlerArg (XML_Parser parser)

Variables
static Processor	cdataSectionProcessor

static Processor	contentProcessor

static Processor	epilogProcessor

static Processor	errorProcessor

static Processor	externalEntityContentProcessor

static Processor	externalEntityInitProcessor

static Processor	externalEntityInitProcessor2

static Processor	externalEntityInitProcessor3

static const XML_Char	implicitContext []

static Processor	internalEntityProcessor

static Processor	prologInitProcessor

static Processor	prologProcessor

Macro Definition Documentation

◆ _dtd

#define _dtd (parser->m_dtd)

Definition at line 636 of file xmlparse.cc.

◆ attInfo

#define attInfo (parser->m_attInfo)

Definition at line 660 of file xmlparse.cc.

◆ attlistDeclHandler

#define attlistDeclHandler (parser->m_attlistDeclHandler)

Definition at line 602 of file xmlparse.cc.

◆ atts

#define atts (parser->m_atts)

Definition at line 653 of file xmlparse.cc.

◆ attsSize

#define attsSize (parser->m_attsSize)

Definition at line 654 of file xmlparse.cc.

◆ buffer

#define buffer (parser->m_buffer)

Definition at line 628 of file xmlparse.cc.

◆ bufferEnd

#define bufferEnd (parser->m_bufferEnd)

Definition at line 630 of file xmlparse.cc.

◆ bufferLim

#define bufferLim (parser->m_bufferLim)

Definition at line 633 of file xmlparse.cc.

◆ bufferPtr

#define bufferPtr (parser->m_bufferPtr)

Definition at line 629 of file xmlparse.cc.

◆ CHAR_HASH

#define CHAR_HASH	(	h,
		c
	)	(((h) * 0xF4243) ^ (unsigned char)(c))

Definition at line 119 of file xmlparse.cc.

◆ characterDataHandler

#define characterDataHandler (parser->m_characterDataHandler)

Definition at line 576 of file xmlparse.cc.

◆ commentHandler

#define commentHandler (parser->m_commentHandler)

Definition at line 579 of file xmlparse.cc.

◆ CONTEXT_SEP

#define CONTEXT_SEP XML_T(ASCII_FF)

Definition at line 5496 of file xmlparse.cc.

◆ curBase

#define curBase (parser->m_curBase)

Definition at line 637 of file xmlparse.cc.

◆ dataBuf

#define dataBuf (parser->m_dataBuf)

Definition at line 634 of file xmlparse.cc.

◆ dataBufEnd

#define dataBufEnd (parser->m_dataBufEnd)

Definition at line 635 of file xmlparse.cc.

◆ declAttributeId

#define declAttributeId (parser->m_declAttributeId)

Definition at line 646 of file xmlparse.cc.

◆ declAttributeIsCdata

#define declAttributeIsCdata (parser->m_declAttributeIsCdata)

Definition at line 647 of file xmlparse.cc.

◆ declAttributeIsId

#define declAttributeIsId (parser->m_declAttributeIsId)

Definition at line 648 of file xmlparse.cc.

◆ declAttributeType

#define declAttributeType (parser->m_declAttributeType)

Definition at line 642 of file xmlparse.cc.

◆ declElementType

#define declElementType (parser->m_declElementType)

Definition at line 645 of file xmlparse.cc.

◆ declEntity

#define declEntity (parser->m_declEntity)

Definition at line 638 of file xmlparse.cc.

◆ declNotationName

#define declNotationName (parser->m_declNotationName)

Definition at line 643 of file xmlparse.cc.

◆ declNotationPublicId

#define declNotationPublicId (parser->m_declNotationPublicId)

Definition at line 644 of file xmlparse.cc.

◆ defaultExpandInternalEntities

#define defaultExpandInternalEntities (parser->m_defaultExpandInternalEntities)

Definition at line 625 of file xmlparse.cc.

◆ defaultHandler

#define defaultHandler (parser->m_defaultHandler)

Definition at line 583 of file xmlparse.cc.

◆ doctypeName

#define doctypeName (parser->m_doctypeName)

Definition at line 639 of file xmlparse.cc.

◆ doctypePubid

#define doctypePubid (parser->m_doctypePubid)

Definition at line 641 of file xmlparse.cc.

◆ doctypeSysid

#define doctypeSysid (parser->m_doctypeSysid)

Definition at line 640 of file xmlparse.cc.

◆ elementDeclHandler

#define elementDeclHandler (parser->m_elementDeclHandler)

Definition at line 601 of file xmlparse.cc.

◆ encoding

#define encoding (parser->m_encoding)

Definition at line 605 of file xmlparse.cc.

◆ endCdataSectionHandler

#define endCdataSectionHandler (parser->m_endCdataSectionHandler)

Definition at line 582 of file xmlparse.cc.

◆ endDoctypeDeclHandler

#define endDoctypeDeclHandler (parser->m_endDoctypeDeclHandler)

Definition at line 585 of file xmlparse.cc.

◆ endElementHandler

#define endElementHandler (parser->m_endElementHandler)

Definition at line 575 of file xmlparse.cc.

◆ endNamespaceDeclHandler

#define endNamespaceDeclHandler (parser->m_endNamespaceDeclHandler)

Definition at line 591 of file xmlparse.cc.

◆ entityDeclHandler

#define entityDeclHandler (parser->m_entityDeclHandler)

Definition at line 603 of file xmlparse.cc.

◆ errorCode

#define errorCode (parser->m_errorCode)

Definition at line 618 of file xmlparse.cc.

◆ eventEndPtr

#define eventEndPtr (parser->m_eventEndPtr)

Definition at line 620 of file xmlparse.cc.

◆ eventPtr

#define eventPtr (parser->m_eventPtr)

Definition at line 619 of file xmlparse.cc.

◆ EXPAND_SPARE

#define EXPAND_SPARE 24

Definition at line 148 of file xmlparse.cc.

◆ externalEntityRefHandler

#define externalEntityRefHandler (parser->m_externalEntityRefHandler)

Definition at line 593 of file xmlparse.cc.

◆ externalEntityRefHandlerArg

#define externalEntityRefHandlerArg (parser->m_externalEntityRefHandlerArg)

Definition at line 595 of file xmlparse.cc.

◆ FREE

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

Definition at line 570 of file xmlparse.cc.

◆ freeBindingList

#define freeBindingList (parser->m_freeBindingList)

Definition at line 650 of file xmlparse.cc.

◆ freeInternalEntities

#define freeInternalEntities (parser->m_freeInternalEntities)

Definition at line 624 of file xmlparse.cc.

◆ freeTagList

#define freeTagList (parser->m_freeTagList)

Definition at line 649 of file xmlparse.cc.

◆ groupConnector

#define groupConnector (parser->m_groupConnector)

Definition at line 663 of file xmlparse.cc.

◆ groupSize

#define groupSize (parser->m_groupSize)

Definition at line 664 of file xmlparse.cc.

◆ handlerArg

#define handlerArg (parser->m_handlerArg)

Definition at line 573 of file xmlparse.cc.

◆ hash_secret_salt

#define hash_secret_salt (parser->m_hash_secret_salt)

Definition at line 674 of file xmlparse.cc.

◆ idAttIndex

#define idAttIndex (parser->m_idAttIndex)

Definition at line 656 of file xmlparse.cc.

◆ inheritedBindings

#define inheritedBindings (parser->m_inheritedBindings)

Definition at line 651 of file xmlparse.cc.

◆ INIT_ATTS_SIZE

#define INIT_ATTS_SIZE 16

Definition at line 143 of file xmlparse.cc.

◆ INIT_ATTS_VERSION

#define INIT_ATTS_VERSION 0xFFFFFFFF

Definition at line 144 of file xmlparse.cc.

◆ INIT_BLOCK_SIZE

#define INIT_BLOCK_SIZE 1024

Definition at line 145 of file xmlparse.cc.

◆ INIT_BUFFER_SIZE

#define INIT_BUFFER_SIZE 1024

Definition at line 146 of file xmlparse.cc.

◆ INIT_DATA_BUF_SIZE

#define INIT_DATA_BUF_SIZE 1024

Definition at line 142 of file xmlparse.cc.

◆ INIT_POWER

#define INIT_POWER 6

Definition at line 5955 of file xmlparse.cc.

◆ INIT_SCAFFOLD_ELEMENTS

#define INIT_SCAFFOLD_ELEMENTS 32

Definition at line 221 of file xmlparse.cc.

◆ INIT_TAG_BUF_SIZE

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

Definition at line 141 of file xmlparse.cc.

◆ initEncoding

#define initEncoding (parser->m_initEncoding)

Definition at line 606 of file xmlparse.cc.

◆ internalEncoding

#define internalEncoding (parser->m_internalEncoding)

Definition at line 607 of file xmlparse.cc.

◆ internalEntityRefHandler

#define internalEntityRefHandler (parser->m_internalEntityRefHandler)

Definition at line 597 of file xmlparse.cc.

◆ MALLOC

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

Definition at line 568 of file xmlparse.cc.

◆ MUST_CONVERT

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

Definition at line 49 of file xmlparse.cc.

◆ namespaceSeparator

#define namespaceSeparator (parser->m_namespaceSeparator)

Definition at line 665 of file xmlparse.cc.

◆ notationDeclHandler

#define notationDeclHandler (parser->m_notationDeclHandler)

Definition at line 588 of file xmlparse.cc.

◆ notStandaloneHandler

#define notStandaloneHandler (parser->m_notStandaloneHandler)

Definition at line 592 of file xmlparse.cc.

◆ ns

#define ns (parser->m_ns)

Definition at line 614 of file xmlparse.cc.

◆ ns_triplets

#define ns_triplets (parser->m_ns_triplets)

Definition at line 615 of file xmlparse.cc.

◆ nsAtts

#define nsAtts (parser->m_nsAtts)

Definition at line 657 of file xmlparse.cc.

◆ nsAttsPower

#define nsAttsPower (parser->m_nsAttsPower)

Definition at line 659 of file xmlparse.cc.

◆ nsAttsVersion

#define nsAttsVersion (parser->m_nsAttsVersion)

Definition at line 658 of file xmlparse.cc.

◆ nSpecifiedAtts

#define nSpecifiedAtts (parser->m_nSpecifiedAtts)

Definition at line 655 of file xmlparse.cc.

◆ openInternalEntities

#define openInternalEntities (parser->m_openInternalEntities)

Definition at line 623 of file xmlparse.cc.

◆ parentParser

#define parentParser (parser->m_parentParser)

Definition at line 666 of file xmlparse.cc.

◆ parseEndByteIndex

#define parseEndByteIndex (parser->m_parseEndByteIndex)

Definition at line 631 of file xmlparse.cc.

◆ parseEndPtr

#define parseEndPtr (parser->m_parseEndPtr)

Definition at line 632 of file xmlparse.cc.

◆ poolAppendChar

#define poolAppendChar	(	pool,
		c
	)

Value:

  (((pool)->ptr == (pool)->end && !poolGrow(pool)) \
   ? 0 \
   : ((*((pool)->ptr)++ = c), 1))

Definition at line 460 of file xmlparse.cc.

◆ poolChop

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

Definition at line 456 of file xmlparse.cc.

◆ poolDiscard

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

Definition at line 458 of file xmlparse.cc.

◆ poolEnd

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

Definition at line 454 of file xmlparse.cc.

◆ poolFinish

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

Definition at line 459 of file xmlparse.cc.

◆ poolLastChar

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

Definition at line 457 of file xmlparse.cc.

◆ poolLength

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

Definition at line 455 of file xmlparse.cc.

◆ poolStart

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

Definition at line 453 of file xmlparse.cc.

◆ position

#define position (parser->m_position)

Definition at line 622 of file xmlparse.cc.

◆ positionPtr

#define positionPtr (parser->m_positionPtr)

Definition at line 621 of file xmlparse.cc.

◆ PROBE_STEP

#define PROBE_STEP	(	hash,
		mask,
		power
	)	((unsigned char)((SECOND_HASH(hash, mask, power)) \| 1))

Definition at line 133 of file xmlparse.cc.

◆ processingInstructionHandler

#define processingInstructionHandler (parser->m_processingInstructionHandler)

Definition at line 577 of file xmlparse.cc.

◆ processor

#define processor (parser->m_processor)

Definition at line 617 of file xmlparse.cc.

◆ prologState

#define prologState (parser->m_prologState)

Definition at line 616 of file xmlparse.cc.

◆ protocolEncodingName

#define protocolEncodingName (parser->m_protocolEncodingName)

Definition at line 613 of file xmlparse.cc.

◆ ps_finalBuffer

#define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

Definition at line 668 of file xmlparse.cc.

◆ ps_parsing

#define ps_parsing (parser->m_parsingStatus.parsing)

Definition at line 667 of file xmlparse.cc.

◆ REALLOC

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

Definition at line 569 of file xmlparse.cc.

◆ ROUND_UP

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

Definition at line 82 of file xmlparse.cc.

◆ SECOND_HASH

#define SECOND_HASH	(	hash,
		mask,
		power
	)	((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

Definition at line 131 of file xmlparse.cc.

◆ skippedEntityHandler

#define skippedEntityHandler (parser->m_skippedEntityHandler)

Definition at line 599 of file xmlparse.cc.

◆ startCdataSectionHandler

#define startCdataSectionHandler (parser->m_startCdataSectionHandler)

Definition at line 580 of file xmlparse.cc.

◆ startDoctypeDeclHandler

#define startDoctypeDeclHandler (parser->m_startDoctypeDeclHandler)

Definition at line 584 of file xmlparse.cc.

◆ startElementHandler

#define startElementHandler (parser->m_startElementHandler)

Definition at line 574 of file xmlparse.cc.

◆ startNamespaceDeclHandler

#define startNamespaceDeclHandler (parser->m_startNamespaceDeclHandler)

Definition at line 589 of file xmlparse.cc.

◆ tagLevel

#define tagLevel (parser->m_tagLevel)

Definition at line 627 of file xmlparse.cc.

◆ tagStack

#define tagStack (parser->m_tagStack)

Definition at line 652 of file xmlparse.cc.

◆ temp2Pool

#define temp2Pool (parser->m_temp2Pool)

Definition at line 662 of file xmlparse.cc.

◆ tempPool

#define tempPool (parser->m_tempPool)

Definition at line 661 of file xmlparse.cc.

◆ unknownEncodingData

#define unknownEncodingData (parser->m_unknownEncodingData)

Definition at line 609 of file xmlparse.cc.

◆ unknownEncodingHandler

#define unknownEncodingHandler (parser->m_unknownEncodingHandler)

Definition at line 600 of file xmlparse.cc.

◆ unknownEncodingHandlerData

#define unknownEncodingHandlerData (parser->m_unknownEncodingHandlerData)

Definition at line 610 of file xmlparse.cc.

◆ unknownEncodingMem

#define unknownEncodingMem (parser->m_unknownEncodingMem)

Definition at line 608 of file xmlparse.cc.

◆ unknownEncodingRelease

#define unknownEncodingRelease (parser->m_unknownEncodingRelease)

Definition at line 612 of file xmlparse.cc.

◆ unparsedEntityDeclHandler

#define unparsedEntityDeclHandler (parser->m_unparsedEntityDeclHandler)

Definition at line 586 of file xmlparse.cc.

◆ userData

#define userData (parser->m_userData)

Definition at line 572 of file xmlparse.cc.

◆ V1

#define V1	(	a,
		b,
		c
	)	XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)

◆ V2

#define V2	(	a,
		b,
		c
	)	XML_L("expat_")V1(a,b,c)

◆ XML_BUILDING_EXPAT

#define XML_BUILDING_EXPAT 1

Definition at line 17 of file xmlparse.cc.

◆ XML_ENCODE_MAX

#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX

Definition at line 44 of file xmlparse.cc.

◆ XML_L

#define XML_L ( x ) x

Definition at line 77 of file xmlparse.cc.

◆ XML_T

#define XML_T ( x ) x

Definition at line 76 of file xmlparse.cc.

◆ XmlConvert

#define XmlConvert XmlUtf8Convert

Definition at line 45 of file xmlparse.cc.

◆ xmlDeclHandler

#define xmlDeclHandler (parser->m_xmlDeclHandler)

Definition at line 604 of file xmlparse.cc.

◆ XmlEncode

#define XmlEncode XmlUtf8Encode

Definition at line 48 of file xmlparse.cc.

◆ XmlGetInternalEncoding

#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding

Definition at line 46 of file xmlparse.cc.

◆ XmlGetInternalEncodingNS [1/2]

#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS

Definition at line 59 of file xmlparse.cc.

◆ XmlGetInternalEncodingNS [2/2]

#define XmlGetInternalEncodingNS XmlGetInternalEncoding

Definition at line 59 of file xmlparse.cc.

◆ XmlInitEncodingNS

#define XmlInitEncodingNS XmlInitEncoding

Definition at line 56 of file xmlparse.cc.

◆ XmlInitUnknownEncodingNS

#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding

Definition at line 57 of file xmlparse.cc.

◆ XmlParseXmlDeclNS

#define XmlParseXmlDeclNS XmlParseXmlDecl

Definition at line 60 of file xmlparse.cc.

Typedef Documentation

◆ ATTRIBUTE_ID

typedef struct attribute_id ATTRIBUTE_ID

◆ BINDING

typedef struct binding BINDING

◆ BLOCK

typedef struct block BLOCK

◆ ICHAR

typedef char ICHAR

Definition at line 50 of file xmlparse.cc.

◆ KEY

typedef const XML_Char* KEY

Definition at line 97 of file xmlparse.cc.

◆ OPEN_INTERNAL_ENTITY

typedef struct open_internal_entity OPEN_INTERNAL_ENTITY

◆ PREFIX

typedef struct prefix PREFIX

◆ TAG

typedef struct tag TAG

Function Documentation

◆ addBinding()

static enum XML_Error addBinding	(	XML_Parser	parser,
		PREFIX *	prefix,
		const ATTRIBUTE_ID *	attId,
		const XML_Char *	uri,
		BINDING **	bindingsPtr
	)

static

Definition at line 3056 of file xmlparse.cc.

{
  static const XML_Char xmlNamespace[] = {
    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 const int xmlLen =
    (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;
  static const XML_Char xmlnsNamespace[] = {
    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_2, ASCII_0, ASCII_0,
    ASCII_0, ASCII_SLASH, ASCII_x, ASCII_m, ASCII_l, ASCII_n, ASCII_s,
    ASCII_SLASH, '\0'
  };
  static const int xmlnsLen =
    (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;
 
  XML_Bool mustBeXML = XML_FALSE;
  XML_Bool isXML = XML_TRUE;
  XML_Bool isXMLNS = XML_TRUE;
 
  BINDING *b;
  int len;
 
  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
  if (*uri == XML_T('\0') && prefix->name)
    return XML_ERROR_UNDECLARING_PREFIX;
 
  if (prefix->name
      && prefix->name[0] == XML_T(ASCII_x)
      && prefix->name[1] == XML_T(ASCII_m)
      && prefix->name[2] == XML_T(ASCII_l)) {
 
    /* Not allowed to bind xmlns */
    if (prefix->name[3] == XML_T(ASCII_n)
        && prefix->name[4] == XML_T(ASCII_s)
        && prefix->name[5] == XML_T('\0'))
      return XML_ERROR_RESERVED_PREFIX_XMLNS;
 
    if (prefix->name[3] == XML_T('\0'))
      mustBeXML = XML_TRUE;
  }
 
  for (len = 0; uri[len]; len++) {
    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
      isXML = XML_FALSE;
 
    if (!mustBeXML && isXMLNS
        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
      isXMLNS = XML_FALSE;
  }
  isXML = isXML && len == xmlLen;
  isXMLNS = isXMLNS && len == xmlnsLen;
 
  if (mustBeXML != isXML)
    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
                     : XML_ERROR_RESERVED_NAMESPACE_URI;
 
  if (isXMLNS)
    return XML_ERROR_RESERVED_NAMESPACE_URI;
 
  if (namespaceSeparator)
    len++;
  if (freeBindingList) {
    b = freeBindingList;
    if (len > b->uriAlloc) {
      XML_Char *temp = (XML_Char *)REALLOC(b->uri,
                          sizeof(XML_Char) * (len + EXPAND_SPARE));
      if (temp == NULL)
        return XML_ERROR_NO_MEMORY;
      b->uri = temp;
      b->uriAlloc = len + EXPAND_SPARE;
    }
    freeBindingList = b->nextTagBinding;
  }
  else {
    b = (BINDING *)MALLOC(sizeof(BINDING));
    if (!b)
      return XML_ERROR_NO_MEMORY;
    b->uri = (XML_Char *)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
    if (!b->uri) {
      FREE(b);
      return XML_ERROR_NO_MEMORY;
    }
    b->uriAlloc = len + EXPAND_SPARE;
  }
  b->uriLen = len;
  memcpy(b->uri, uri, len * sizeof(XML_Char));
  if (namespaceSeparator)
    b->uri[len - 1] = namespaceSeparator;
  b->prefix = prefix;
  b->attId = attId;
  b->prevPrefixBinding = prefix->binding;
  /* NULL binding when default namespace undeclared */
  if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)
    prefix->binding = NULL;
  else
    prefix->binding = b;
  b->nextTagBinding = *bindingsPtr;
  *bindingsPtr = b;
  /* if attId == NULL then we are not starting a namespace scope */
  if (attId && startNamespaceDeclHandler)
    startNamespaceDeclHandler(handlerArg, prefix->name,
                              prefix->binding ? uri : 0);
  return XML_ERROR_NONE;
}

References _dtd, ASCII_0, ASCII_1, ASCII_2, ASCII_3, ASCII_8, ASCII_9, ASCII_a, ASCII_c, ASCII_COLON, ASCII_e, ASCII_g, ASCII_h, ASCII_L, ASCII_l, ASCII_M, ASCII_m, ASCII_n, ASCII_o, ASCII_p, ASCII_PERIOD, ASCII_r, ASCII_s, ASCII_SLASH, ASCII_t, ASCII_w, ASCII_X, ASCII_x, binding::attId, prefix::binding, EXPAND_SPARE, FREE, freeBindingList, handlerArg, MALLOC, prefix::name, namespaceSeparator, binding::nextTagBinding, binding::prefix, binding::prevPrefixBinding, REALLOC, startNamespaceDeclHandler, binding::uri, binding::uriAlloc, binding::uriLen, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_RESERVED_NAMESPACE_URI, XML_ERROR_RESERVED_PREFIX_XML, XML_ERROR_RESERVED_PREFIX_XMLNS, XML_ERROR_UNDECLARING_PREFIX, XML_FALSE, XML_T, and XML_TRUE.

Referenced by setContext(), and storeAtts().

◆ appendAttributeValue()

static enum XML_Error appendAttributeValue	(	XML_Parser	parser,
		const ENCODING *	enc,
		XML_Bool	isCdata,
		const char *	ptr,
		const char *	end,
		STRING_POOL *	pool
	)

static

Definition at line 4944 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  for (;;) {
    const char *next;
    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
    switch (tok) {
    case XML_TOK_NONE:
      return XML_ERROR_NONE;
    case XML_TOK_INVALID:
      if (enc == encoding)
        eventPtr = next;
      return XML_ERROR_INVALID_TOKEN;
    case XML_TOK_PARTIAL:
      if (enc == encoding)
        eventPtr = ptr;
      return XML_ERROR_INVALID_TOKEN;
    case XML_TOK_CHAR_REF:
      {
        XML_Char buf[XML_ENCODE_MAX];
        int i;
        int n = XmlCharRefNumber(enc, ptr);
        if (n < 0) {
          if (enc == encoding)
            eventPtr = ptr;
          return XML_ERROR_BAD_CHAR_REF;
        }
        if (!isCdata
            && n == 0x20 /* space */
            && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
          break;
        n = XmlEncode(n, (ICHAR *)buf);
        if (!n) {
          if (enc == encoding)
            eventPtr = ptr;
          return XML_ERROR_BAD_CHAR_REF;
        }
        for (i = 0; i < n; i++) {
          if (!poolAppendChar(pool, buf[i]))
            return XML_ERROR_NO_MEMORY;
        }
      }
      break;
    case XML_TOK_DATA_CHARS:
      if (!poolAppend(pool, enc, ptr, next))
        return XML_ERROR_NO_MEMORY;
      break;
    case XML_TOK_TRAILING_CR:
      next = ptr + enc->minBytesPerChar;
      /* fall through */
    case XML_TOK_ATTRIBUTE_VALUE_S:
    case XML_TOK_DATA_NEWLINE:
      if (!isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
        break;
      if (!poolAppendChar(pool, 0x20))
        return XML_ERROR_NO_MEMORY;
      break;
    case XML_TOK_ENTITY_REF:
      {
        const XML_Char *name;
        ENTITY *entity;
        char checkEntityDecl;
        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
                                              ptr + enc->minBytesPerChar,
                                              next - enc->minBytesPerChar);
        if (ch) {
          if (!poolAppendChar(pool, ch))
                return XML_ERROR_NO_MEMORY;
          break;
        }
        name = poolStoreString(&temp2Pool, enc,
                               ptr + enc->minBytesPerChar,
                               next - enc->minBytesPerChar);
        if (!name)
          return XML_ERROR_NO_MEMORY;
        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
        poolDiscard(&temp2Pool);
        /* First, determine if a check for an existing declaration is needed;
           if yes, check that the entity exists, and that it is internal.
        */
        if (pool == &dtd->pool)  /* are we called from prolog? */
          checkEntityDecl =
#ifdef XML_DTD
              prologState.documentEntity &&
#endif /* XML_DTD */
              (dtd->standalone
               ? !openInternalEntities
               : !dtd->hasParamEntityRefs);
        else /* if (pool == &tempPool): we are called from content */
          checkEntityDecl = !dtd->hasParamEntityRefs || dtd->standalone;
        if (checkEntityDecl) {
          if (!entity)
            return XML_ERROR_UNDEFINED_ENTITY;
          else if (!entity->is_internal)
            return XML_ERROR_ENTITY_DECLARED_IN_PE;
        }
        else if (!entity) {
          /* Cannot report skipped entity here - see comments on
             skippedEntityHandler.
          if (skippedEntityHandler)
            skippedEntityHandler(handlerArg, name, 0);
          */
          /* Cannot call the default handler because this would be
             out of sync with the call to the startElementHandler.
          if ((pool == &tempPool) && defaultHandler)
            reportDefault(parser, enc, ptr, next);
          */
          break;
        }
        if (entity->open) {
          if (enc == encoding)
            eventPtr = ptr;
          return XML_ERROR_RECURSIVE_ENTITY_REF;
        }
        if (entity->notation) {
          if (enc == encoding)
            eventPtr = ptr;
          return XML_ERROR_BINARY_ENTITY_REF;
        }
        if (!entity->textPtr) {
          if (enc == encoding)
            eventPtr = ptr;
          return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
        }
        else {
          enum XML_Error result;
          const XML_Char *textEnd = entity->textPtr + entity->textLen;
          entity->open = XML_TRUE;
          result = appendAttributeValue(parser, internalEncoding, isCdata,
                                        (char *)entity->textPtr,
                                        (char *)textEnd, pool);
          entity->open = XML_FALSE;
          if (result)
            return result;
        }
      }
      break;
    default:
      if (enc == encoding)
        eventPtr = ptr;
      return XML_ERROR_UNEXPECTED_STATE;
    }
    ptr = next;
  }
  /* not reached */
}

References _dtd, appendAttributeValue(), eventPtr, DTD::generalEntities, DTD::hasParamEntityRefs, internalEncoding, ENTITY::is_internal, lookup(), encoding::minBytesPerChar, CLHEP::detail::n, G4InuclParticleNames::name(), ENTITY::notation, ENTITY::open, openInternalEntities, geant4_check_module_cycles::parser, DTD::pool, poolAppend(), poolAppendChar, poolDiscard, poolLastChar, poolLength, poolStoreString(), prologState, DTD::standalone, temp2Pool, ENTITY::textLen, ENTITY::textPtr, XML_ENCODE_MAX, XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF, XML_ERROR_BAD_CHAR_REF, XML_ERROR_BINARY_ENTITY_REF, XML_ERROR_ENTITY_DECLARED_IN_PE, XML_ERROR_INVALID_TOKEN, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_RECURSIVE_ENTITY_REF, XML_ERROR_UNDEFINED_ENTITY, XML_ERROR_UNEXPECTED_STATE, XML_FALSE, XML_TOK_ATTRIBUTE_VALUE_S, XML_TOK_CHAR_REF, XML_TOK_DATA_CHARS, XML_TOK_DATA_NEWLINE, XML_TOK_ENTITY_REF, XML_TOK_INVALID, XML_TOK_NONE, XML_TOK_PARTIAL, XML_TOK_TRAILING_CR, XML_TRUE, XmlAttributeValueTok, XmlCharRefNumber, XmlEncode, and XmlPredefinedEntityName.

Referenced by appendAttributeValue(), and storeAttributeValue().

◆ build_model()

static XML_Content * build_model ( XML_Parser parser )

static

Definition at line 6366 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  XML_Content *ret;
  XML_Content *cpos;
  XML_Char * str;
  int allocsize = (dtd->scaffCount * sizeof(XML_Content)
                   + (dtd->contentStringLen * sizeof(XML_Char)));
 
  ret = (XML_Content *)MALLOC(allocsize);
  if (!ret)
    return NULL;
 
  str =  (XML_Char *) (&ret[dtd->scaffCount]);
  cpos = &ret[1];
 
  build_node(parser, 0, ret, &cpos, &str);
  return ret;
}

References _dtd, build_node(), DTD::contentStringLen, MALLOC, geant4_check_module_cycles::parser, and DTD::scaffCount.

Referenced by doProlog().

◆ build_node()

static void build_node	(	XML_Parser	parser,
		int	src_node,
		XML_Content *	dest,
		XML_Content **	contpos,
		XML_Char **	strpos
	)

static

Definition at line 6328 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  dest->type = dtd->scaffold[src_node].type;
  dest->quant = dtd->scaffold[src_node].quant;
  if (dest->type == XML_CTYPE_NAME) {
    const XML_Char *src;
    dest->name = *strpos;
    src = dtd->scaffold[src_node].name;
    for (;;) {
      *(*strpos)++ = *src;
      if (!*src)
        break;
      src++;
    }
    dest->numchildren = 0;
    dest->children = NULL;
  }
  else {
    unsigned int i;
    int cn;
    dest->numchildren = dtd->scaffold[src_node].childcnt;
    dest->children = *contpos;
    *contpos += dest->numchildren;
    for (i = 0, cn = dtd->scaffold[src_node].firstchild;
         i < dest->numchildren;
         i++, cn = dtd->scaffold[cn].nextsib) {
      build_node(parser, cn, &(dest->children[i]), contpos, strpos);
    }
    dest->name = NULL;
  }
}

References _dtd, build_node(), CONTENT_SCAFFOLD::childcnt, XML_cp::children, CONTENT_SCAFFOLD::firstchild, XML_cp::name, CONTENT_SCAFFOLD::name, CONTENT_SCAFFOLD::nextsib, XML_cp::numchildren, geant4_check_module_cycles::parser, XML_cp::quant, CONTENT_SCAFFOLD::quant, DTD::scaffold, XML_cp::type, CONTENT_SCAFFOLD::type, and XML_CTYPE_NAME.

Referenced by build_model(), and build_node().

◆ cdataSectionProcessor()

static enum XML_Error PTRCALL cdataSectionProcessor	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 3173 of file xmlparse.cc.

{
  enum XML_Error result = doCdataSection(parser, encoding, &start, end,
                                         endPtr, (XML_Bool)!ps_finalBuffer);
  if (result != XML_ERROR_NONE)
    return result;
  if (start) {
    if (parentParser) {  /* we are parsing an external entity */
      processor = externalEntityContentProcessor;
      return externalEntityContentProcessor(parser, start, end, endPtr);
    }
    else {
      processor = contentProcessor;
      return contentProcessor(parser, start, end, endPtr);
    }
  }
  return result;
}

References contentProcessor, doCdataSection(), externalEntityContentProcessor, parentParser, geant4_check_module_cycles::parser, processor, ps_finalBuffer, and XML_ERROR_NONE.

◆ contentProcessor()

static enum XML_Error PTRCALL contentProcessor	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 2106 of file xmlparse.cc.

{
  enum XML_Error result = doContent(parser, 0, encoding, start, end,
                                    endPtr, (XML_Bool)!ps_finalBuffer);
  if (result == XML_ERROR_NONE) {
    if (!storeRawNames(parser))
      return XML_ERROR_NO_MEMORY;
  }
  return result;
}

References doContent(), geant4_check_module_cycles::parser, ps_finalBuffer, storeRawNames(), XML_ERROR_NO_MEMORY, and XML_ERROR_NONE.

◆ copyEntityTable()

static int copyEntityTable	(	XML_Parser	oldParser,
		HASH_TABLE *	newTable,
		STRING_POOL *	newPool,
		const HASH_TABLE *	oldTable
	)

static

Definition at line 5889 of file xmlparse.cc.

{
  HASH_TABLE_ITER iter;
  const XML_Char *cachedOldBase = NULL;
  const XML_Char *cachedNewBase = NULL;
 
  hashTableIterInit(&iter, oldTable);
 
  for (;;) {
    ENTITY *newE;
    const XML_Char *name;
    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
    if (!oldE)
      break;
    name = poolCopyString(newPool, oldE->name);
    if (!name)
      return 0;
    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
    if (!newE)
      return 0;
    if (oldE->systemId) {
      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
      if (!tem)
        return 0;
      newE->systemId = tem;
      if (oldE->base) {
        if (oldE->base == cachedOldBase)
          newE->base = cachedNewBase;
        else {
          cachedOldBase = oldE->base;
          tem = poolCopyString(newPool, cachedOldBase);
          if (!tem)
            return 0;
          cachedNewBase = newE->base = tem;
        }
      }
      if (oldE->publicId) {
        tem = poolCopyString(newPool, oldE->publicId);
        if (!tem)
          return 0;
        newE->publicId = tem;
      }
    }
    else {
      const XML_Char *tem = poolCopyStringN(newPool, oldE->textPtr,
                                            oldE->textLen);
      if (!tem)
        return 0;
      newE->textPtr = tem;
      newE->textLen = oldE->textLen;
    }
    if (oldE->notation) {
      const XML_Char *tem = poolCopyString(newPool, oldE->notation);
      if (!tem)
        return 0;
      newE->notation = tem;
    }
    newE->is_param = oldE->is_param;
    newE->is_internal = oldE->is_internal;
  }
  return 1;
}

References ENTITY::base, hashTableIterInit(), hashTableIterNext(), ENTITY::is_internal, ENTITY::is_param, lookup(), ENTITY::name, G4InuclParticleNames::name(), ENTITY::notation, poolCopyString(), poolCopyStringN(), ENTITY::publicId, ENTITY::systemId, ENTITY::textLen, and ENTITY::textPtr.

Referenced by dtdCopy().

◆ defineAttribute()

static int defineAttribute	(	ELEMENT_TYPE *	type,
		ATTRIBUTE_ID *	attId,
		XML_Bool	isCdata,
		XML_Bool	isId,
		const XML_Char *	dfltValue,
		XML_Parser	parser
	)

static

Definition at line 5362 of file xmlparse.cc.

{
  DEFAULT_ATTRIBUTE *att;
  if (value || isId) {
    /* The handling of default attributes gets messed up if we have
       a default which duplicates a non-default. */
    int i;
    for (i = 0; i < type->nDefaultAtts; i++)
      if (attId == type->defaultAtts[i].id)
        return 1;
    if (isId && !type->idAtt && !attId->xmlns)
      type->idAtt = attId;
  }
  if (type->nDefaultAtts == type->allocDefaultAtts) {
    if (type->allocDefaultAtts == 0) {
      type->allocDefaultAtts = 8;
      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts
                            * sizeof(DEFAULT_ATTRIBUTE));
      if (!type->defaultAtts)
        return 0;
    }
    else {
      DEFAULT_ATTRIBUTE *temp;
      int count = type->allocDefaultAtts * 2;
      temp = (DEFAULT_ATTRIBUTE *)
        REALLOC(type->defaultAtts, (count * sizeof(DEFAULT_ATTRIBUTE)));
      if (temp == NULL)
        return 0;
      type->allocDefaultAtts = count;
      type->defaultAtts = temp;
    }
  }
  att = type->defaultAtts + type->nDefaultAtts;
  att->id = attId;
  att->value = value;
  att->isCdata = isCdata;
  if (!isCdata)
    attId->maybeTokenized = XML_TRUE;
  type->nDefaultAtts += 1;
  return 1;
}

References ELEMENT_TYPE::allocDefaultAtts, ELEMENT_TYPE::defaultAtts, DEFAULT_ATTRIBUTE::id, ELEMENT_TYPE::idAtt, DEFAULT_ATTRIBUTE::isCdata, MALLOC, attribute_id::maybeTokenized, ELEMENT_TYPE::nDefaultAtts, REALLOC, DEFAULT_ATTRIBUTE::value, XML_TRUE, and attribute_id::xmlns.

Referenced by doProlog().

◆ destroyBindings()

static void FASTCALL destroyBindings	(	BINDING *	bindings,
		XML_Parser	parser
	)

static

Definition at line 1123 of file xmlparse.cc.

{
  for (;;) {
    BINDING *b = bindings;
    if (!b)
      break;
    bindings = b->nextTagBinding;
    FREE(b->uri);
    FREE(b);
  }
}

References FREE, binding::nextTagBinding, and binding::uri.

Referenced by XML_ParserFree().

◆ doCdataSection()

static enum XML_Error doCdataSection	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char **	startPtr,
		const char *	end,
		const char **	nextPtr,
		XML_Bool	haveMore
	)

static

Definition at line 3199 of file xmlparse.cc.

{
  const char *s = *startPtr;
  const char **eventPP;
  const char **eventEndPP;
  if (enc == encoding) {
    eventPP = &eventPtr;
    *eventPP = s;
    eventEndPP = &eventEndPtr;
  }
  else {
    eventPP = &(openInternalEntities->internalEventPtr);
    eventEndPP = &(openInternalEntities->internalEventEndPtr);
  }
  *eventPP = s;
  *startPtr = NULL;
 
  for (;;) {
    const char *next;
    int tok = XmlCdataSectionTok(enc, s, end, &next);
    *eventEndPP = next;
    switch (tok) {
    case XML_TOK_CDATA_SECT_CLOSE:
      if (endCdataSectionHandler)
        endCdataSectionHandler(handlerArg);
#if 0
      /* see comment under XML_TOK_CDATA_SECT_OPEN */
      else if (characterDataHandler)
        characterDataHandler(handlerArg, dataBuf, 0);
#endif
      else if (defaultHandler)
        reportDefault(parser, enc, s, next);
      *startPtr = next;
      *nextPtr = next;
      if (ps_parsing == XML_FINISHED)
        return XML_ERROR_ABORTED;
      else
        return XML_ERROR_NONE;
    case XML_TOK_DATA_NEWLINE:
      if (characterDataHandler) {
        XML_Char c = 0xA;
        characterDataHandler(handlerArg, &c, 1);
      }
      else if (defaultHandler)
        reportDefault(parser, enc, s, next);
      break;
    case XML_TOK_DATA_CHARS:
      {
        XML_CharacterDataHandler charDataHandler = characterDataHandler;
        if (charDataHandler) {
          if (MUST_CONVERT(enc, s)) {
            for (;;) {
              ICHAR *dataPtr = (ICHAR *)dataBuf;
              XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
              *eventEndPP = next;
              charDataHandler(handlerArg, dataBuf,
                              (int)(dataPtr - (ICHAR *)dataBuf));
              if (s == next)
                break;
              *eventPP = s;
            }
          }
          else
            charDataHandler(handlerArg,
                            (XML_Char *)s,
                            (int)((XML_Char *)next - (XML_Char *)s));
        }
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
      }
      break;
    case XML_TOK_INVALID:
      *eventPP = next;
      return XML_ERROR_INVALID_TOKEN;
    case XML_TOK_PARTIAL_CHAR:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_PARTIAL_CHAR;
    case XML_TOK_PARTIAL:
    case XML_TOK_NONE:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_UNCLOSED_CDATA_SECTION;
    default:
      *eventPP = next;
      return XML_ERROR_UNEXPECTED_STATE;
    }
 
    *eventPP = s = next;
    switch (ps_parsing) {
    case XML_SUSPENDED:
      *nextPtr = next;
      return XML_ERROR_NONE;
    case XML_FINISHED:
      return XML_ERROR_ABORTED;
    default: ;
    }
  }
  /* not reached */
}

References characterDataHandler, dataBuf, dataBufEnd, defaultHandler, endCdataSectionHandler, eventEndPtr, eventPtr, handlerArg, MUST_CONVERT, openInternalEntities, geant4_check_module_cycles::parser, ps_parsing, reportDefault(), s, XML_ERROR_ABORTED, XML_ERROR_INVALID_TOKEN, XML_ERROR_NONE, XML_ERROR_PARTIAL_CHAR, XML_ERROR_UNCLOSED_CDATA_SECTION, XML_ERROR_UNEXPECTED_STATE, XML_FINISHED, XML_SUSPENDED, XML_TOK_CDATA_SECT_CLOSE, XML_TOK_DATA_CHARS, XML_TOK_DATA_NEWLINE, XML_TOK_INVALID, XML_TOK_NONE, XML_TOK_PARTIAL, XML_TOK_PARTIAL_CHAR, XmlCdataSectionTok, and XmlConvert.

Referenced by cdataSectionProcessor(), and doContent().

◆ doContent()

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

Definition at line 2237 of file xmlparse.cc.

{
  /* save one level of indirection */
  DTD * const dtd = _dtd;
 
  const char **eventPP;
  const char **eventEndPP;
  if (enc == encoding) {
    eventPP = &eventPtr;
    eventEndPP = &eventEndPtr;
  }
  else {
    eventPP = &(openInternalEntities->internalEventPtr);
    eventEndPP = &(openInternalEntities->internalEventEndPtr);
  }
  *eventPP = s;
 
  for (;;) {
    const char *next = s; /* XmlContentTok doesn't always set the last arg */
    int tok = XmlContentTok(enc, s, end, &next);
    *eventEndPP = next;
    switch (tok) {
    case XML_TOK_TRAILING_CR:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      *eventEndPP = end;
      if (characterDataHandler) {
        XML_Char c = 0xA;
        characterDataHandler(handlerArg, &c, 1);
      }
      else if (defaultHandler)
        reportDefault(parser, enc, s, end);
      /* We are at the end of the final buffer, should we check for
         XML_SUSPENDED, XML_FINISHED?
      */
      if (startTagLevel == 0)
        return XML_ERROR_NO_ELEMENTS;
      if (tagLevel != startTagLevel)
        return XML_ERROR_ASYNC_ENTITY;
      *nextPtr = end;
      return XML_ERROR_NONE;
    case XML_TOK_NONE:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      if (startTagLevel > 0) {
        if (tagLevel != startTagLevel)
          return XML_ERROR_ASYNC_ENTITY;
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_NO_ELEMENTS;
    case XML_TOK_INVALID:
      *eventPP = next;
      return XML_ERROR_INVALID_TOKEN;
    case XML_TOK_PARTIAL:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_UNCLOSED_TOKEN;
    case XML_TOK_PARTIAL_CHAR:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_PARTIAL_CHAR;
    case XML_TOK_ENTITY_REF:
      {
        const XML_Char *name;
        ENTITY *entity;
        XML_Char ch = (XML_Char) XmlPredefinedEntityName(enc,
                                              s + enc->minBytesPerChar,
                                              next - enc->minBytesPerChar);
        if (ch) {
          if (characterDataHandler)
            characterDataHandler(handlerArg, &ch, 1);
          else if (defaultHandler)
            reportDefault(parser, enc, s, next);
          break;
        }
        name = poolStoreString(&dtd->pool, enc,
                                s + enc->minBytesPerChar,
                                next - enc->minBytesPerChar);
        if (!name)
          return XML_ERROR_NO_MEMORY;
        entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
        poolDiscard(&dtd->pool);
        /* First, determine if a check for an existing declaration is needed;
           if yes, check that the entity exists, and that it is internal,
           otherwise call the skipped entity or default handler.
        */
        if (!dtd->hasParamEntityRefs || dtd->standalone) {
          if (!entity)
            return XML_ERROR_UNDEFINED_ENTITY;
          else if (!entity->is_internal)
            return XML_ERROR_ENTITY_DECLARED_IN_PE;
        }
        else if (!entity) {
          if (skippedEntityHandler)
            skippedEntityHandler(handlerArg, name, 0);
          else if (defaultHandler)
            reportDefault(parser, enc, s, next);
          break;
        }
        if (entity->open)
          return XML_ERROR_RECURSIVE_ENTITY_REF;
        if (entity->notation)
          return XML_ERROR_BINARY_ENTITY_REF;
        if (entity->textPtr) {
          enum XML_Error result;
          if (!defaultExpandInternalEntities) {
            if (skippedEntityHandler)
              skippedEntityHandler(handlerArg, entity->name, 0);
            else if (defaultHandler)
              reportDefault(parser, enc, s, next);
            break;
          }
          result = processInternalEntity(parser, entity, XML_FALSE);
          if (result != XML_ERROR_NONE)
            return result;
        }
        else if (externalEntityRefHandler) {
          const XML_Char *context;
          entity->open = XML_TRUE;
          context = getContext(parser);
          entity->open = XML_FALSE;
          if (!context)
            return XML_ERROR_NO_MEMORY;
          if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                        context,
                                        entity->base,
                                        entity->systemId,
                                        entity->publicId))
            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
          poolDiscard(&tempPool);
        }
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
        break;
      }
    case XML_TOK_START_TAG_NO_ATTS:
      /* fall through */
    case XML_TOK_START_TAG_WITH_ATTS:
      {
        TAG *tag;
        enum XML_Error result;
        XML_Char *toPtr;
        if (freeTagList) {
          tag = freeTagList;
          freeTagList = freeTagList->parent;
        }
        else {
          tag = (TAG *)MALLOC(sizeof(TAG));
          if (!tag)
            return XML_ERROR_NO_MEMORY;
          tag->buf = (char *)MALLOC(INIT_TAG_BUF_SIZE);
          if (!tag->buf) {
            FREE(tag);
            return XML_ERROR_NO_MEMORY;
          }
          tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
        }
        tag->bindings = NULL;
        tag->parent = tagStack;
        tagStack = tag;
        tag->name.localPart = NULL;
        tag->name.prefix = NULL;
        tag->rawName = s + enc->minBytesPerChar;
        tag->rawNameLength = XmlNameLength(enc, tag->rawName);
        ++tagLevel;
        {
          const char *rawNameEnd = tag->rawName + tag->rawNameLength;
          const char *fromPtr = tag->rawName;
          toPtr = (XML_Char *)tag->buf;
          for (;;) {
            int bufSize;
            int convLen;
            XmlConvert(enc,
                       &fromPtr, rawNameEnd,
                       (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
            convLen = (int)(toPtr - (XML_Char *)tag->buf);
            if (fromPtr == rawNameEnd) {
              tag->name.strLen = convLen;
              break;
            }
            bufSize = (int)(tag->bufEnd - tag->buf) << 1;
            {
              char *temp = (char *)REALLOC(tag->buf, bufSize);
              if (temp == NULL)
                return XML_ERROR_NO_MEMORY;
              tag->buf = temp;
              tag->bufEnd = temp + bufSize;
              toPtr = (XML_Char *)temp + convLen;
            }
          }
        }
        tag->name.str = (XML_Char *)tag->buf;
        *toPtr = XML_T('\0');
        result = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings));
        if (result)
          return result;
        if (startElementHandler)
          startElementHandler(handlerArg, tag->name.str,
                              (const XML_Char **)atts);
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
        poolClear(&tempPool);
        break;
      }
    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
      /* fall through */
    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
      {
        const char *rawName = s + enc->minBytesPerChar;
        enum XML_Error result;
        BINDING *bindings = NULL;
        XML_Bool noElmHandlers = XML_TRUE;
        TAG_NAME name;
        name.str = poolStoreString(&tempPool, enc, rawName,
                                   rawName + XmlNameLength(enc, rawName));
        if (!name.str)
          return XML_ERROR_NO_MEMORY;
        poolFinish(&tempPool);
        result = storeAtts(parser, enc, s, &name, &bindings);
        if (result)
          return result;
        poolFinish(&tempPool);
        if (startElementHandler) {
          startElementHandler(handlerArg, name.str, (const XML_Char **)atts);
          noElmHandlers = XML_FALSE;
        }
        if (endElementHandler) {
          if (startElementHandler)
            *eventPP = *eventEndPP;
          endElementHandler(handlerArg, name.str);
          noElmHandlers = XML_FALSE;
        }
        if (noElmHandlers && defaultHandler)
          reportDefault(parser, enc, s, next);
        poolClear(&tempPool);
        while (bindings) {
          BINDING *b = bindings;
          if (endNamespaceDeclHandler)
            endNamespaceDeclHandler(handlerArg, b->prefix->name);
          bindings = bindings->nextTagBinding;
          b->nextTagBinding = freeBindingList;
          freeBindingList = b;
          b->prefix->binding = b->prevPrefixBinding;
        }
      }
      if (tagLevel == 0)
        return epilogProcessor(parser, next, end, nextPtr);
      break;
    case XML_TOK_END_TAG:
      if (tagLevel == startTagLevel)
        return XML_ERROR_ASYNC_ENTITY;
      else {
        int len;
        const char *rawName;
        TAG *tag = tagStack;
        tagStack = tag->parent;
        tag->parent = freeTagList;
        freeTagList = tag;
        rawName = s + enc->minBytesPerChar*2;
        len = XmlNameLength(enc, rawName);
        if (len != tag->rawNameLength
            || memcmp(tag->rawName, rawName, len) != 0) {
          *eventPP = rawName;
          return XML_ERROR_TAG_MISMATCH;
        }
        --tagLevel;
        if (endElementHandler) {
          const XML_Char *localPart;
          const XML_Char *prefix;
          XML_Char *uri;
          localPart = tag->name.localPart;
          if (ns && localPart) {
            /* localPart and prefix may have been overwritten in
               tag->name.str, since this points to the binding->uri
               buffer which gets re-used; so we have to add them again
            */
            uri = (XML_Char *)tag->name.str + tag->name.uriLen;
            /* don't need to check for space - already done in storeAtts() */
            while (*localPart) *uri++ = *localPart++;
            prefix = (XML_Char *)tag->name.prefix;
            if (ns_triplets && prefix) {
              *uri++ = namespaceSeparator;
              while (*prefix) *uri++ = *prefix++;
             }
            *uri = XML_T('\0');
          }
          endElementHandler(handlerArg, tag->name.str);
        }
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
        while (tag->bindings) {
          BINDING *b = tag->bindings;
          if (endNamespaceDeclHandler)
            endNamespaceDeclHandler(handlerArg, b->prefix->name);
          tag->bindings = tag->bindings->nextTagBinding;
          b->nextTagBinding = freeBindingList;
          freeBindingList = b;
          b->prefix->binding = b->prevPrefixBinding;
        }
        if (tagLevel == 0)
          return epilogProcessor(parser, next, end, nextPtr);
      }
      break;
    case XML_TOK_CHAR_REF:
      {
        int n = XmlCharRefNumber(enc, s);
        if (n < 0)
          return XML_ERROR_BAD_CHAR_REF;
        if (characterDataHandler) {
          XML_Char buf[XML_ENCODE_MAX];
          characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *)buf));
        }
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
      }
      break;
    case XML_TOK_XML_DECL:
      return XML_ERROR_MISPLACED_XML_PI;
    case XML_TOK_DATA_NEWLINE:
      if (characterDataHandler) {
        XML_Char c = 0xA;
        characterDataHandler(handlerArg, &c, 1);
      }
      else if (defaultHandler)
        reportDefault(parser, enc, s, next);
      break;
    case XML_TOK_CDATA_SECT_OPEN:
      {
        enum XML_Error result;
        if (startCdataSectionHandler)
          startCdataSectionHandler(handlerArg);
#if 0
        /* Suppose you doing a transformation on a document that involves
           changing only the character data.  You set up a defaultHandler
           and a characterDataHandler.  The defaultHandler simply copies
           characters through.  The characterDataHandler does the
           transformation and writes the characters out escaping them as
           necessary.  This case will fail to work if we leave out the
           following two lines (because & and < inside CDATA sections will
           be incorrectly escaped).
 
           However, now we have a start/endCdataSectionHandler, so it seems
           easier to let the user deal with this.
        */
        else if (characterDataHandler)
          characterDataHandler(handlerArg, dataBuf, 0);
#endif
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
        result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);
        if (result != XML_ERROR_NONE)
          return result;
        else if (!next) {
          processor = cdataSectionProcessor;
          return result;
        }
      }
      break;
    case XML_TOK_TRAILING_RSQB:
      if (haveMore) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      if (characterDataHandler) {
        if (MUST_CONVERT(enc, s)) {
          ICHAR *dataPtr = (ICHAR *)dataBuf;
          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
          characterDataHandler(handlerArg, dataBuf,
                               (int)(dataPtr - (ICHAR *)dataBuf));
        }
        else
          characterDataHandler(handlerArg,
                               (XML_Char *)s,
                               (int)((XML_Char *)end - (XML_Char *)s));
      }
      else if (defaultHandler)
        reportDefault(parser, enc, s, end);
      /* We are at the end of the final buffer, should we check for
         XML_SUSPENDED, XML_FINISHED?
      */
      if (startTagLevel == 0) {
        *eventPP = end;
        return XML_ERROR_NO_ELEMENTS;
      }
      if (tagLevel != startTagLevel) {
        *eventPP = end;
        return XML_ERROR_ASYNC_ENTITY;
      }
      *nextPtr = end;
      return XML_ERROR_NONE;
    case XML_TOK_DATA_CHARS:
      {
        XML_CharacterDataHandler charDataHandler = characterDataHandler;
        if (charDataHandler) {
          if (MUST_CONVERT(enc, s)) {
            for (;;) {
              ICHAR *dataPtr = (ICHAR *)dataBuf;
              XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
              *eventEndPP = s;
              charDataHandler(handlerArg, dataBuf,
                              (int)(dataPtr - (ICHAR *)dataBuf));
              if (s == next)
                break;
              *eventPP = s;
            }
          }
          else
            charDataHandler(handlerArg,
                            (XML_Char *)s,
                            (int)((XML_Char *)next - (XML_Char *)s));
        }
        else if (defaultHandler)
          reportDefault(parser, enc, s, next);
      }
      break;
    case XML_TOK_PI:
      if (!reportProcessingInstruction(parser, enc, s, next))
        return XML_ERROR_NO_MEMORY;
      break;
    case XML_TOK_COMMENT:
      if (!reportComment(parser, enc, s, next))
        return XML_ERROR_NO_MEMORY;
      break;
    default:
      if (defaultHandler)
        reportDefault(parser, enc, s, next);
      break;
    }
    *eventPP = s = next;
    switch (ps_parsing) {
    case XML_SUSPENDED:
      *nextPtr = next;
      return XML_ERROR_NONE;
    case XML_FINISHED:
      return XML_ERROR_ABORTED;
    default: ;
    }
  }
  /* not reached */
}

References _dtd, atts, ENTITY::base, prefix::binding, tag::bindings, tag::buf, tag::bufEnd, cdataSectionProcessor, characterDataHandler, g4zmq::context, dataBuf, dataBufEnd, defaultExpandInternalEntities, defaultHandler, doCdataSection(), endElementHandler, endNamespaceDeclHandler, epilogProcessor, eventEndPtr, eventPtr, externalEntityRefHandler, externalEntityRefHandlerArg, FREE, freeBindingList, freeTagList, DTD::generalEntities, getContext(), handlerArg, DTD::hasParamEntityRefs, INIT_TAG_BUF_SIZE, ENTITY::is_internal, TAG_NAME::localPart, lookup(), MALLOC, encoding::minBytesPerChar, MUST_CONVERT, CLHEP::detail::n, prefix::name, tag::name, ENTITY::name, G4InuclParticleNames::name(), namespaceSeparator, binding::nextTagBinding, ENTITY::notation, ns, ns_triplets, ENTITY::open, openInternalEntities, tag::parent, geant4_check_module_cycles::parser, DTD::pool, poolClear(), poolDiscard, poolFinish, poolStoreString(), binding::prefix, TAG_NAME::prefix, binding::prevPrefixBinding, processInternalEntity(), processor, ps_parsing, ENTITY::publicId, tag::rawName, tag::rawNameLength, REALLOC, reportComment(), reportDefault(), reportProcessingInstruction(), s, skippedEntityHandler, DTD::standalone, startCdataSectionHandler, startElementHandler, storeAtts(), TAG_NAME::str, TAG_NAME::strLen, ENTITY::systemId, tagLevel, tagStack, tempPool, ENTITY::textPtr, TAG_NAME::uriLen, XML_ENCODE_MAX, XML_ERROR_ABORTED, XML_ERROR_ASYNC_ENTITY, XML_ERROR_BAD_CHAR_REF, XML_ERROR_BINARY_ENTITY_REF, XML_ERROR_ENTITY_DECLARED_IN_PE, XML_ERROR_EXTERNAL_ENTITY_HANDLING, XML_ERROR_INVALID_TOKEN, XML_ERROR_MISPLACED_XML_PI, XML_ERROR_NO_ELEMENTS, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_PARTIAL_CHAR, XML_ERROR_RECURSIVE_ENTITY_REF, XML_ERROR_TAG_MISMATCH, XML_ERROR_UNCLOSED_TOKEN, XML_ERROR_UNDEFINED_ENTITY, XML_FALSE, XML_FINISHED, XML_SUSPENDED, XML_T, XML_TOK_CDATA_SECT_OPEN, XML_TOK_CHAR_REF, XML_TOK_COMMENT, XML_TOK_DATA_CHARS, XML_TOK_DATA_NEWLINE, XML_TOK_EMPTY_ELEMENT_NO_ATTS, XML_TOK_EMPTY_ELEMENT_WITH_ATTS, XML_TOK_END_TAG, XML_TOK_ENTITY_REF, XML_TOK_INVALID, XML_TOK_NONE, XML_TOK_PARTIAL, XML_TOK_PARTIAL_CHAR, XML_TOK_PI, XML_TOK_START_TAG_NO_ATTS, XML_TOK_START_TAG_WITH_ATTS, XML_TOK_TRAILING_CR, XML_TOK_TRAILING_RSQB, XML_TOK_XML_DECL, XML_TRUE, XmlCharRefNumber, XmlContentTok, XmlConvert, XmlEncode, XmlNameLength, and XmlPredefinedEntityName.

Referenced by contentProcessor(), externalEntityContentProcessor(), internalEntityProcessor(), and processInternalEntity().

◆ doProlog()

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

Definition at line 3750 of file xmlparse.cc.

{
#ifdef XML_DTD
  static const XML_Char externalSubsetName[] = { ASCII_HASH , '\0' };
#endif /* XML_DTD */
  static const XML_Char atypeCDATA[] =
      { 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 atypeIDREF[] =
      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
  static const XML_Char atypeIDREFS[] =
      { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
  static const XML_Char atypeENTITY[] =
      { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
  static const XML_Char atypeENTITIES[] = { ASCII_E, ASCII_N,
      ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
  static const XML_Char atypeNMTOKEN[] = {
      ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
  static const XML_Char atypeNMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T,
      ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
  static const XML_Char notationPrefix[] = { ASCII_N, ASCII_O, ASCII_T,
      ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0' };
  static const XML_Char enumValueSep[] = { ASCII_PIPE, '\0' };
  static const XML_Char enumValueStart[] = { ASCII_LPAREN, '\0' };
 
  /* save one level of indirection */
  DTD * const dtd = _dtd;
 
  const char **eventPP;
  const char **eventEndPP;
  enum XML_Content_Quant quant;
 
  if (enc == encoding) {
    eventPP = &eventPtr;
    eventEndPP = &eventEndPtr;
  }
  else {
    eventPP = &(openInternalEntities->internalEventPtr);
    eventEndPP = &(openInternalEntities->internalEventEndPtr);
  }
 
  for (;;) {
    int role;
    XML_Bool handleDefault = XML_TRUE;
    *eventPP = s;
    *eventEndPP = next;
    if (tok <= 0) {
      if (haveMore && tok != XML_TOK_INVALID) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      switch (tok) {
      case XML_TOK_INVALID:
        *eventPP = next;
        return XML_ERROR_INVALID_TOKEN;
      case XML_TOK_PARTIAL:
        return XML_ERROR_UNCLOSED_TOKEN;
      case XML_TOK_PARTIAL_CHAR:
        return XML_ERROR_PARTIAL_CHAR;
      case -XML_TOK_PROLOG_S:
        tok = -tok;
        break;
      case XML_TOK_NONE:
#ifdef XML_DTD
        /* for internal PE NOT referenced between declarations */
        if (enc != encoding && !openInternalEntities->betweenDecl) {
          *nextPtr = s;
          return XML_ERROR_NONE;
        }
        /* WFC: PE Between Declarations - must check that PE contains
           complete markup, not only for external PEs, but also for
           internal PEs if the reference occurs between declarations.
        */
        if (isParamEntity || enc != encoding) {
          if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)
              == XML_ROLE_ERROR)
            return XML_ERROR_INCOMPLETE_PE;
          *nextPtr = s;
          return XML_ERROR_NONE;
        }
#endif /* XML_DTD */
        return XML_ERROR_NO_ELEMENTS;
      default:
        tok = -tok;
        next = end;
        break;
      }
    }
    role = XmlTokenRole(&prologState, tok, s, next, enc);
    switch (role) {
    case XML_ROLE_XML_DECL:
      {
        enum XML_Error result = processXmlDecl(parser, 0, s, next);
        if (result != XML_ERROR_NONE)
          return result;
        enc = encoding;
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_DOCTYPE_NAME:
      if (startDoctypeDeclHandler) {
        doctypeName = poolStoreString(&tempPool, enc, s, next);
        if (!doctypeName)
          return XML_ERROR_NO_MEMORY;
        poolFinish(&tempPool);
        doctypePubid = NULL;
        handleDefault = XML_FALSE;
      }
      doctypeSysid = NULL; /* always initialize to NULL */
      break;
    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
      if (startDoctypeDeclHandler) {
        startDoctypeDeclHandler(handlerArg, doctypeName, doctypeSysid,
                                doctypePubid, 1);
        doctypeName = NULL;
        poolClear(&tempPool);
        handleDefault = XML_FALSE;
      }
      break;
#ifdef XML_DTD
    case XML_ROLE_TEXT_DECL:
      {
        enum XML_Error result = processXmlDecl(parser, 1, s, next);
        if (result != XML_ERROR_NONE)
          return result;
        enc = encoding;
        handleDefault = XML_FALSE;
      }
      break;
#endif /* XML_DTD */
    case XML_ROLE_DOCTYPE_PUBLIC_ID:
#ifdef XML_DTD
      useForeignDTD = XML_FALSE;
      declEntity = (ENTITY *)lookup(parser,
                                    &dtd->paramEntities,
                                    externalSubsetName,
                                    sizeof(ENTITY));
      if (!declEntity)
        return XML_ERROR_NO_MEMORY;
#endif /* XML_DTD */
      dtd->hasParamEntityRefs = XML_TRUE;
      if (startDoctypeDeclHandler) {
        XML_Char *pubId;
        if (!XmlIsPublicId(enc, s, next, eventPP))
          return XML_ERROR_PUBLICID;
        pubId = poolStoreString(&tempPool, enc,
                                s + enc->minBytesPerChar,
                                next - enc->minBytesPerChar);
        if (!pubId)
          return XML_ERROR_NO_MEMORY;
        normalizePublicId(pubId);
        poolFinish(&tempPool);
        doctypePubid = pubId;
        handleDefault = XML_FALSE;
        goto alreadyChecked;
      }
      /* fall through */
    case XML_ROLE_ENTITY_PUBLIC_ID:
      if (!XmlIsPublicId(enc, s, next, eventPP))
        return XML_ERROR_PUBLICID;
    alreadyChecked:
      if (dtd->keepProcessing && declEntity) {
        XML_Char *tem = poolStoreString(&dtd->pool,
                                        enc,
                                        s + enc->minBytesPerChar,
                                        next - enc->minBytesPerChar);
        if (!tem)
          return XML_ERROR_NO_MEMORY;
        normalizePublicId(tem);
        declEntity->publicId = tem;
        poolFinish(&dtd->pool);
        if (entityDeclHandler)
          handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_DOCTYPE_CLOSE:
      if (doctypeName) {
        startDoctypeDeclHandler(handlerArg, doctypeName,
                                doctypeSysid, doctypePubid, 0);
        poolClear(&tempPool);
        handleDefault = XML_FALSE;
      }
      /* doctypeSysid will be non-NULL in the case of a previous
         XML_ROLE_DOCTYPE_SYSTEM_ID, even if startDoctypeDeclHandler
         was not set, indicating an external subset
      */
#ifdef XML_DTD
      if (doctypeSysid || useForeignDTD) {
        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
        dtd->hasParamEntityRefs = XML_TRUE;
        if (paramEntityParsing && externalEntityRefHandler) {
          ENTITY *entity = (ENTITY *)lookup(parser,
                                            &dtd->paramEntities,
                                            externalSubsetName,
                                            sizeof(ENTITY));
          if (!entity)
            return XML_ERROR_NO_MEMORY;
          if (useForeignDTD)
            entity->base = curBase;
          dtd->paramEntityRead = XML_FALSE;
          if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                        0,
                                        entity->base,
                                        entity->systemId,
                                        entity->publicId))
            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
          if (dtd->paramEntityRead) {
            if (!dtd->standalone &&
                notStandaloneHandler &&
                !notStandaloneHandler(handlerArg))
              return XML_ERROR_NOT_STANDALONE;
          }
          /* if we didn't read the foreign DTD then this means that there
             is no external subset and we must reset dtd->hasParamEntityRefs
          */
          else if (!doctypeSysid)
            dtd->hasParamEntityRefs = hadParamEntityRefs;
          /* end of DTD - no need to update dtd->keepProcessing */
        }
        useForeignDTD = XML_FALSE;
      }
#endif /* XML_DTD */
      if (endDoctypeDeclHandler) {
        endDoctypeDeclHandler(handlerArg);
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_INSTANCE_START:
#ifdef XML_DTD
      /* if there is no DOCTYPE declaration then now is the
         last chance to read the foreign DTD
      */
      if (useForeignDTD) {
        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
        dtd->hasParamEntityRefs = XML_TRUE;
        if (paramEntityParsing && externalEntityRefHandler) {
          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
                                            externalSubsetName,
                                            sizeof(ENTITY));
          if (!entity)
            return XML_ERROR_NO_MEMORY;
          entity->base = curBase;
          dtd->paramEntityRead = XML_FALSE;
          if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                        0,
                                        entity->base,
                                        entity->systemId,
                                        entity->publicId))
            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
          if (dtd->paramEntityRead) {
            if (!dtd->standalone &&
                notStandaloneHandler &&
                !notStandaloneHandler(handlerArg))
              return XML_ERROR_NOT_STANDALONE;
          }
          /* if we didn't read the foreign DTD then this means that there
             is no external subset and we must reset dtd->hasParamEntityRefs
          */
          else
            dtd->hasParamEntityRefs = hadParamEntityRefs;
          /* end of DTD - no need to update dtd->keepProcessing */
        }
      }
#endif /* XML_DTD */
      processor = contentProcessor;
      return contentProcessor(parser, s, end, nextPtr);
    case XML_ROLE_ATTLIST_ELEMENT_NAME:
      declElementType = getElementType(parser, enc, s, next);
      if (!declElementType)
        return XML_ERROR_NO_MEMORY;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_NAME:
      declAttributeId = getAttributeId(parser, enc, s, next);
      if (!declAttributeId)
        return XML_ERROR_NO_MEMORY;
      declAttributeIsCdata = XML_FALSE;
      declAttributeType = NULL;
      declAttributeIsId = XML_FALSE;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
      declAttributeIsCdata = XML_TRUE;
      declAttributeType = atypeCDATA;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_ID:
      declAttributeIsId = XML_TRUE;
      declAttributeType = atypeID;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
      declAttributeType = atypeIDREF;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
      declAttributeType = atypeIDREFS;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
      declAttributeType = atypeENTITY;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
      declAttributeType = atypeENTITIES;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
      declAttributeType = atypeNMTOKEN;
      goto checkAttListDeclHandler;
    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
      declAttributeType = atypeNMTOKENS;
    checkAttListDeclHandler:
      if (dtd->keepProcessing && attlistDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
      if (dtd->keepProcessing && attlistDeclHandler) {
        const XML_Char *prefix;
        if (declAttributeType) {
          prefix = enumValueSep;
        }
        else {
          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE
                    ? notationPrefix
                    : enumValueStart);
        }
        if (!poolAppendString(&tempPool, prefix))
          return XML_ERROR_NO_MEMORY;
        if (!poolAppend(&tempPool, enc, s, next))
          return XML_ERROR_NO_MEMORY;
        declAttributeType = tempPool.start;
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
      if (dtd->keepProcessing) {
        if (!defineAttribute(declElementType, declAttributeId,
                             declAttributeIsCdata, declAttributeIsId,
                             0, parser))
          return XML_ERROR_NO_MEMORY;
        if (attlistDeclHandler && declAttributeType) {
          if (*declAttributeType == XML_T(ASCII_LPAREN)
              || (*declAttributeType == XML_T(ASCII_N)
                  && declAttributeType[1] == XML_T(ASCII_O))) {
            /* Enumerated or Notation type */
            if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
                || !poolAppendChar(&tempPool, XML_T('\0')))
              return XML_ERROR_NO_MEMORY;
            declAttributeType = tempPool.start;
            poolFinish(&tempPool);
          }
          *eventEndPP = s;
          attlistDeclHandler(handlerArg, declElementType->name,
                             declAttributeId->name, declAttributeType,
                             0, role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
          poolClear(&tempPool);
          handleDefault = XML_FALSE;
        }
      }
      break;
    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
      if (dtd->keepProcessing) {
        const XML_Char *attVal;
        enum XML_Error result =
          storeAttributeValue(parser, enc, declAttributeIsCdata,
                              s + enc->minBytesPerChar,
                              next - enc->minBytesPerChar,
                              &dtd->pool);
        if (result)
          return result;
        attVal = poolStart(&dtd->pool);
        poolFinish(&dtd->pool);
        /* ID attributes aren't allowed to have a default */
        if (!defineAttribute(declElementType, declAttributeId,
                             declAttributeIsCdata, XML_FALSE, attVal, parser))
          return XML_ERROR_NO_MEMORY;
        if (attlistDeclHandler && declAttributeType) {
          if (*declAttributeType == XML_T(ASCII_LPAREN)
              || (*declAttributeType == XML_T(ASCII_N)
                  && declAttributeType[1] == XML_T(ASCII_O))) {
            /* Enumerated or Notation type */
            if (!poolAppendChar(&tempPool, XML_T(ASCII_RPAREN))
                || !poolAppendChar(&tempPool, XML_T('\0')))
              return XML_ERROR_NO_MEMORY;
            declAttributeType = tempPool.start;
            poolFinish(&tempPool);
          }
          *eventEndPP = s;
          attlistDeclHandler(handlerArg, declElementType->name,
                             declAttributeId->name, declAttributeType,
                             attVal,
                             role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
          poolClear(&tempPool);
          handleDefault = XML_FALSE;
        }
      }
      break;
    case XML_ROLE_ENTITY_VALUE:
      if (dtd->keepProcessing) {
        enum XML_Error result = storeEntityValue(parser, enc,
                                            s + enc->minBytesPerChar,
                                            next - enc->minBytesPerChar);
        if (declEntity) {
          declEntity->textPtr = poolStart(&dtd->entityValuePool);
          declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));
          poolFinish(&dtd->entityValuePool);
          if (entityDeclHandler) {
            *eventEndPP = s;
            entityDeclHandler(handlerArg,
                              declEntity->name,
                              declEntity->is_param,
                              declEntity->textPtr,
                              declEntity->textLen,
                              curBase, 0, 0, 0);
            handleDefault = XML_FALSE;
          }
        }
        else
          poolDiscard(&dtd->entityValuePool);
        if (result != XML_ERROR_NONE)
          return result;
      }
      break;
    case XML_ROLE_DOCTYPE_SYSTEM_ID:
#ifdef XML_DTD
      useForeignDTD = XML_FALSE;
#endif /* XML_DTD */
      dtd->hasParamEntityRefs = XML_TRUE;
      if (startDoctypeDeclHandler) {
        doctypeSysid = poolStoreString(&tempPool, enc,
                                       s + enc->minBytesPerChar,
                                       next - enc->minBytesPerChar);
        if (doctypeSysid == NULL)
          return XML_ERROR_NO_MEMORY;
        poolFinish(&tempPool);
        handleDefault = XML_FALSE;
      }
#ifdef XML_DTD
      else
        /* use externalSubsetName to make doctypeSysid non-NULL
           for the case where no startDoctypeDeclHandler is set */
        doctypeSysid = externalSubsetName;
#endif /* XML_DTD */
      if (!dtd->standalone
#ifdef XML_DTD
          && !paramEntityParsing
#endif /* XML_DTD */
          && notStandaloneHandler
          && !notStandaloneHandler(handlerArg))
        return XML_ERROR_NOT_STANDALONE;
#ifndef XML_DTD
      break;
#else /* XML_DTD */
      if (!declEntity) {
        declEntity = (ENTITY *)lookup(parser,
                                      &dtd->paramEntities,
                                      externalSubsetName,
                                      sizeof(ENTITY));
        if (!declEntity)
          return XML_ERROR_NO_MEMORY;
        declEntity->publicId = NULL;
      }
      /* fall through */
#endif /* XML_DTD */
    case XML_ROLE_ENTITY_SYSTEM_ID:
      if (dtd->keepProcessing && declEntity) {
        declEntity->systemId = poolStoreString(&dtd->pool, enc,
                                               s + enc->minBytesPerChar,
                                               next - enc->minBytesPerChar);
        if (!declEntity->systemId)
          return XML_ERROR_NO_MEMORY;
        declEntity->base = curBase;
        poolFinish(&dtd->pool);
        if (entityDeclHandler)
          handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_ENTITY_COMPLETE:
      if (dtd->keepProcessing && declEntity && entityDeclHandler) {
        *eventEndPP = s;
        entityDeclHandler(handlerArg,
                          declEntity->name,
                          declEntity->is_param,
                          0,0,
                          declEntity->base,
                          declEntity->systemId,
                          declEntity->publicId,
                          0);
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_ENTITY_NOTATION_NAME:
      if (dtd->keepProcessing && declEntity) {
        declEntity->notation = poolStoreString(&dtd->pool, enc, s, next);
        if (!declEntity->notation)
          return XML_ERROR_NO_MEMORY;
        poolFinish(&dtd->pool);
        if (unparsedEntityDeclHandler) {
          *eventEndPP = s;
          unparsedEntityDeclHandler(handlerArg,
                                    declEntity->name,
                                    declEntity->base,
                                    declEntity->systemId,
                                    declEntity->publicId,
                                    declEntity->notation);
          handleDefault = XML_FALSE;
        }
        else if (entityDeclHandler) {
          *eventEndPP = s;
          entityDeclHandler(handlerArg,
                            declEntity->name,
                            0,0,0,
                            declEntity->base,
                            declEntity->systemId,
                            declEntity->publicId,
                            declEntity->notation);
          handleDefault = XML_FALSE;
        }
      }
      break;
    case XML_ROLE_GENERAL_ENTITY_NAME:
      {
        if (XmlPredefinedEntityName(enc, s, next)) {
          declEntity = NULL;
          break;
        }
        if (dtd->keepProcessing) {
          const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
          if (!name)
            return XML_ERROR_NO_MEMORY;
          declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities, name,
                                        sizeof(ENTITY));
          if (!declEntity)
            return XML_ERROR_NO_MEMORY;
          if (declEntity->name != name) {
            poolDiscard(&dtd->pool);
            declEntity = NULL;
          }
          else {
            poolFinish(&dtd->pool);
            declEntity->publicId = NULL;
            declEntity->is_param = XML_FALSE;
            /* if we have a parent parser or are reading an internal parameter
               entity, then the entity declaration is not considered "internal"
            */
            declEntity->is_internal = !(parentParser || openInternalEntities);
            if (entityDeclHandler)
              handleDefault = XML_FALSE;
          }
        }
        else {
          poolDiscard(&dtd->pool);
          declEntity = NULL;
        }
      }
      break;
    case XML_ROLE_PARAM_ENTITY_NAME:
#ifdef XML_DTD
      if (dtd->keepProcessing) {
        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
        if (!name)
          return XML_ERROR_NO_MEMORY;
        declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
                                           name, sizeof(ENTITY));
        if (!declEntity)
          return XML_ERROR_NO_MEMORY;
        if (declEntity->name != name) {
          poolDiscard(&dtd->pool);
          declEntity = NULL;
        }
        else {
          poolFinish(&dtd->pool);
          declEntity->publicId = NULL;
          declEntity->is_param = XML_TRUE;
          /* if we have a parent parser or are reading an internal parameter
             entity, then the entity declaration is not considered "internal"
          */
          declEntity->is_internal = !(parentParser || openInternalEntities);
          if (entityDeclHandler)
            handleDefault = XML_FALSE;
        }
      }
      else {
        poolDiscard(&dtd->pool);
        declEntity = NULL;
      }
#else /* not XML_DTD */
      declEntity = NULL;
#endif /* XML_DTD */
      break;
    case XML_ROLE_NOTATION_NAME:
      declNotationPublicId = NULL;
      declNotationName = NULL;
      if (notationDeclHandler) {
        declNotationName = poolStoreString(&tempPool, enc, s, next);
        if (!declNotationName)
          return XML_ERROR_NO_MEMORY;
        poolFinish(&tempPool);
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_NOTATION_PUBLIC_ID:
      if (!XmlIsPublicId(enc, s, next, eventPP))
        return XML_ERROR_PUBLICID;
      if (declNotationName) {  /* means notationDeclHandler != NULL */
        XML_Char *tem = poolStoreString(&tempPool,
                                        enc,
                                        s + enc->minBytesPerChar,
                                        next - enc->minBytesPerChar);
        if (!tem)
          return XML_ERROR_NO_MEMORY;
        normalizePublicId(tem);
        declNotationPublicId = tem;
        poolFinish(&tempPool);
        handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_NOTATION_SYSTEM_ID:
      if (declNotationName && notationDeclHandler) {
        const XML_Char *systemId
          = poolStoreString(&tempPool, enc,
                            s + enc->minBytesPerChar,
                            next - enc->minBytesPerChar);
        if (!systemId)
          return XML_ERROR_NO_MEMORY;
        *eventEndPP = s;
        notationDeclHandler(handlerArg,
                            declNotationName,
                            curBase,
                            systemId,
                            declNotationPublicId);
        handleDefault = XML_FALSE;
      }
      poolClear(&tempPool);
      break;
    case XML_ROLE_NOTATION_NO_SYSTEM_ID:
      if (declNotationPublicId && notationDeclHandler) {
        *eventEndPP = s;
        notationDeclHandler(handlerArg,
                            declNotationName,
                            curBase,
                            0,
                            declNotationPublicId);
        handleDefault = XML_FALSE;
      }
      poolClear(&tempPool);
      break;
    case XML_ROLE_ERROR:
      switch (tok) {
      case XML_TOK_PARAM_ENTITY_REF:
        /* PE references in internal subset are
           not allowed within declarations. */
        return XML_ERROR_PARAM_ENTITY_REF;
      case XML_TOK_XML_DECL:
        return XML_ERROR_MISPLACED_XML_PI;
      default:
        return XML_ERROR_SYNTAX;
      }
#ifdef XML_DTD
    case XML_ROLE_IGNORE_SECT:
      {
        enum XML_Error result;
        if (defaultHandler)
          reportDefault(parser, enc, s, next);
        handleDefault = XML_FALSE;
        result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
        if (result != XML_ERROR_NONE)
          return result;
        else if (!next) {
          processor = ignoreSectionProcessor;
          return result;
        }
      }
      break;
#endif /* XML_DTD */
    case XML_ROLE_GROUP_OPEN:
      if (prologState.level >= groupSize) {
        if (groupSize) {
          char *temp = (char *)REALLOC(groupConnector, groupSize *= 2);
          if (temp == NULL)
            return XML_ERROR_NO_MEMORY;
          groupConnector = temp;
          if (dtd->scaffIndex) {
            int *temp = (int *)REALLOC(dtd->scaffIndex,
                          groupSize * sizeof(int));
            if (temp == NULL)
              return XML_ERROR_NO_MEMORY;
            dtd->scaffIndex = temp;
          }
        }
        else {
          groupConnector = (char *)MALLOC(groupSize = 32);
          if (!groupConnector)
            return XML_ERROR_NO_MEMORY;
        }
      }
      groupConnector[prologState.level] = 0;
      if (dtd->in_eldecl) {
        int myindex = nextScaffoldPart(parser);
        if (myindex < 0)
          return XML_ERROR_NO_MEMORY;
        dtd->scaffIndex[dtd->scaffLevel] = myindex;
        dtd->scaffLevel++;
        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
        if (elementDeclHandler)
          handleDefault = XML_FALSE;
      }
      break;
    case XML_ROLE_GROUP_SEQUENCE:
      if (groupConnector[prologState.level] == ASCII_PIPE)
        return XML_ERROR_SYNTAX;
      groupConnector[prologState.level] = ASCII_COMMA;
      if (dtd->in_eldecl && elementDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_GROUP_CHOICE:
      if (groupConnector[prologState.level] == ASCII_COMMA)
        return XML_ERROR_SYNTAX;
      if (dtd->in_eldecl
          && !groupConnector[prologState.level]
          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
              != XML_CTYPE_MIXED)
          ) {
        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
            = XML_CTYPE_CHOICE;
        if (elementDeclHandler)
          handleDefault = XML_FALSE;
      }
      groupConnector[prologState.level] = ASCII_PIPE;
      break;
    case XML_ROLE_PARAM_ENTITY_REF:
#ifdef XML_DTD
    case XML_ROLE_INNER_PARAM_ENTITY_REF:
      dtd->hasParamEntityRefs = XML_TRUE;
      if (!paramEntityParsing)
        dtd->keepProcessing = dtd->standalone;
      else {
        const XML_Char *name;
        ENTITY *entity;
        name = poolStoreString(&dtd->pool, enc,
                                s + enc->minBytesPerChar,
                                next - enc->minBytesPerChar);
        if (!name)
          return XML_ERROR_NO_MEMORY;
        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
        poolDiscard(&dtd->pool);
        /* first, determine if a check for an existing declaration is needed;
           if yes, check that the entity exists, and that it is internal,
           otherwise call the skipped entity handler
        */
        if (prologState.documentEntity &&
            (dtd->standalone
             ? !openInternalEntities
             : !dtd->hasParamEntityRefs)) {
          if (!entity)
            return XML_ERROR_UNDEFINED_ENTITY;
          else if (!entity->is_internal)
            return XML_ERROR_ENTITY_DECLARED_IN_PE;
        }
        else if (!entity) {
          dtd->keepProcessing = dtd->standalone;
          /* cannot report skipped entities in declarations */
          if ((role == XML_ROLE_PARAM_ENTITY_REF) && skippedEntityHandler) {
            skippedEntityHandler(handlerArg, name, 1);
            handleDefault = XML_FALSE;
          }
          break;
        }
        if (entity->open)
          return XML_ERROR_RECURSIVE_ENTITY_REF;
        if (entity->textPtr) {
          enum XML_Error result;
          XML_Bool betweenDecl =
            (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
          result = processInternalEntity(parser, entity, betweenDecl);
          if (result != XML_ERROR_NONE)
            return result;
          handleDefault = XML_FALSE;
          break;
        }
        if (externalEntityRefHandler) {
          dtd->paramEntityRead = XML_FALSE;
          entity->open = XML_TRUE;
          if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                        0,
                                        entity->base,
                                        entity->systemId,
                                        entity->publicId)) {
            entity->open = XML_FALSE;
            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
          }
          entity->open = XML_FALSE;
          handleDefault = XML_FALSE;
          if (!dtd->paramEntityRead) {
            dtd->keepProcessing = dtd->standalone;
            break;
          }
        }
        else {
          dtd->keepProcessing = dtd->standalone;
          break;
        }
      }
#endif /* XML_DTD */
      if (!dtd->standalone &&
          notStandaloneHandler &&
          !notStandaloneHandler(handlerArg))
        return XML_ERROR_NOT_STANDALONE;
      break;
 
    /* Element declaration stuff */
 
    case XML_ROLE_ELEMENT_NAME:
      if (elementDeclHandler) {
        declElementType = getElementType(parser, enc, s, next);
        if (!declElementType)
          return XML_ERROR_NO_MEMORY;
        dtd->scaffLevel = 0;
        dtd->scaffCount = 0;
        dtd->in_eldecl = XML_TRUE;
        handleDefault = XML_FALSE;
      }
      break;
 
    case XML_ROLE_CONTENT_ANY:
    case XML_ROLE_CONTENT_EMPTY:
      if (dtd->in_eldecl) {
        if (elementDeclHandler) {
          XML_Content * content = (XML_Content *) MALLOC(sizeof(XML_Content));
          if (!content)
            return XML_ERROR_NO_MEMORY;
          content->quant = XML_CQUANT_NONE;
          content->name = NULL;
          content->numchildren = 0;
          content->children = NULL;
          content->type = ((role == XML_ROLE_CONTENT_ANY) ?
                           XML_CTYPE_ANY :
                           XML_CTYPE_EMPTY);
          *eventEndPP = s;
          elementDeclHandler(handlerArg, declElementType->name, content);
          handleDefault = XML_FALSE;
        }
        dtd->in_eldecl = XML_FALSE;
      }
      break;
 
    case XML_ROLE_CONTENT_PCDATA:
      if (dtd->in_eldecl) {
        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
            = XML_CTYPE_MIXED;
        if (elementDeclHandler)
          handleDefault = XML_FALSE;
      }
      break;
 
    case XML_ROLE_CONTENT_ELEMENT:
      quant = XML_CQUANT_NONE;
      goto elementContent;
    case XML_ROLE_CONTENT_ELEMENT_OPT:
      quant = XML_CQUANT_OPT;
      goto elementContent;
    case XML_ROLE_CONTENT_ELEMENT_REP:
      quant = XML_CQUANT_REP;
      goto elementContent;
    case XML_ROLE_CONTENT_ELEMENT_PLUS:
      quant = XML_CQUANT_PLUS;
    elementContent:
      if (dtd->in_eldecl) {
        ELEMENT_TYPE *el;
        const XML_Char *name;
        int nameLen;
        const char *nxt = (quant == XML_CQUANT_NONE
                           ? next
                           : next - enc->minBytesPerChar);
        int myindex = nextScaffoldPart(parser);
        if (myindex < 0)
          return XML_ERROR_NO_MEMORY;
        dtd->scaffold[myindex].type = XML_CTYPE_NAME;
        dtd->scaffold[myindex].quant = quant;
        el = getElementType(parser, enc, s, nxt);
        if (!el)
          return XML_ERROR_NO_MEMORY;
        name = el->name;
        dtd->scaffold[myindex].name = name;
        nameLen = 0;
        for (; name[nameLen++]; );
        dtd->contentStringLen +=  nameLen;
        if (elementDeclHandler)
          handleDefault = XML_FALSE;
      }
      break;
 
    case XML_ROLE_GROUP_CLOSE:
      quant = XML_CQUANT_NONE;
      goto closeGroup;
    case XML_ROLE_GROUP_CLOSE_OPT:
      quant = XML_CQUANT_OPT;
      goto closeGroup;
    case XML_ROLE_GROUP_CLOSE_REP:
      quant = XML_CQUANT_REP;
      goto closeGroup;
    case XML_ROLE_GROUP_CLOSE_PLUS:
      quant = XML_CQUANT_PLUS;
    closeGroup:
      if (dtd->in_eldecl) {
        if (elementDeclHandler)
          handleDefault = XML_FALSE;
        dtd->scaffLevel--;
        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
        if (dtd->scaffLevel == 0) {
          if (!handleDefault) {
            XML_Content *model = build_model(parser);
            if (!model)
              return XML_ERROR_NO_MEMORY;
            *eventEndPP = s;
            elementDeclHandler(handlerArg, declElementType->name, model);
          }
          dtd->in_eldecl = XML_FALSE;
          dtd->contentStringLen = 0;
        }
      }
      break;
      /* End element declaration stuff */
 
    case XML_ROLE_PI:
      if (!reportProcessingInstruction(parser, enc, s, next))
        return XML_ERROR_NO_MEMORY;
      handleDefault = XML_FALSE;
      break;
    case XML_ROLE_COMMENT:
      if (!reportComment(parser, enc, s, next))
        return XML_ERROR_NO_MEMORY;
      handleDefault = XML_FALSE;
      break;
    case XML_ROLE_NONE:
      switch (tok) {
      case XML_TOK_BOM:
        handleDefault = XML_FALSE;
        break;
      }
      break;
    case XML_ROLE_DOCTYPE_NONE:
      if (startDoctypeDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_ENTITY_NONE:
      if (dtd->keepProcessing && entityDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_NOTATION_NONE:
      if (notationDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_ATTLIST_NONE:
      if (dtd->keepProcessing && attlistDeclHandler)
        handleDefault = XML_FALSE;
      break;
    case XML_ROLE_ELEMENT_NONE:
      if (elementDeclHandler)
        handleDefault = XML_FALSE;
      break;
    } /* end of big switch */
 
    if (handleDefault && defaultHandler)
      reportDefault(parser, enc, s, next);
 
    switch (ps_parsing) {
    case XML_SUSPENDED:
      *nextPtr = next;
      return XML_ERROR_NONE;
    case XML_FINISHED:
      return XML_ERROR_ABORTED;
    default:
      s = next;
      tok = XmlPrologTok(enc, s, end, &next);
    }
  }
  /* not reached */
}

Referenced by internalEntityProcessor(), processInternalEntity(), and prologProcessor().

◆ dtdCopy()

static int dtdCopy	(	XML_Parser	oldParser,
		DTD *	newDtd,
		const DTD *	oldDtd,
		const XML_Memory_Handling_Suite *	ms
	)

static

Definition at line 5757 of file xmlparse.cc.

{
  HASH_TABLE_ITER iter;
 
  /* Copy the prefix table. */
 
  hashTableIterInit(&iter, &(oldDtd->prefixes));
  for (;;) {
    const XML_Char *name;
    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
    if (!oldP)
      break;
    name = poolCopyString(&(newDtd->pool), oldP->name);
    if (!name)
      return 0;
    if (!lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
      return 0;
  }
 
  hashTableIterInit(&iter, &(oldDtd->attributeIds));
 
  /* Copy the attribute id table. */
 
  for (;;) {
    ATTRIBUTE_ID *newA;
    const XML_Char *name;
    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
 
    if (!oldA)
      break;
    /* Remember to allocate the scratch byte before the name. */
    if (!poolAppendChar(&(newDtd->pool), XML_T('\0')))
      return 0;
    name = poolCopyString(&(newDtd->pool), oldA->name);
    if (!name)
      return 0;
    ++name;
    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
                                  sizeof(ATTRIBUTE_ID));
    if (!newA)
      return 0;
    newA->maybeTokenized = oldA->maybeTokenized;
    if (oldA->prefix) {
      newA->xmlns = oldA->xmlns;
      if (oldA->prefix == &oldDtd->defaultPrefix)
        newA->prefix = &newDtd->defaultPrefix;
      else
        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
                                        oldA->prefix->name, 0);
    }
  }
 
  /* Copy the element type table. */
 
  hashTableIterInit(&iter, &(oldDtd->elementTypes));
 
  for (;;) {
    int i;
    ELEMENT_TYPE *newE;
    const XML_Char *name;
    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
    if (!oldE)
      break;
    name = poolCopyString(&(newDtd->pool), oldE->name);
    if (!name)
      return 0;
    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
                                  sizeof(ELEMENT_TYPE));
    if (!newE)
      return 0;
    if (oldE->nDefaultAtts) {
      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
          ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
      if (!newE->defaultAtts) {
        ms->free_fcn(newE);
        return 0;
      }
    }
    if (oldE->idAtt)
      newE->idAtt = (ATTRIBUTE_ID *)
          lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0);
    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
    if (oldE->prefix)
      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
                                      oldE->prefix->name, 0);
    for (i = 0; i < newE->nDefaultAtts; i++) {
      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)
          lookup(oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
      if (oldE->defaultAtts[i].value) {
        newE->defaultAtts[i].value
            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
        if (!newE->defaultAtts[i].value)
          return 0;
      }
      else
        newE->defaultAtts[i].value = NULL;
    }
  }
 
  /* Copy the entity tables. */
  if (!copyEntityTable(oldParser,
                       &(newDtd->generalEntities),
                       &(newDtd->pool),
                       &(oldDtd->generalEntities)))
      return 0;
 
#ifdef XML_DTD
  if (!copyEntityTable(oldParser,
                       &(newDtd->paramEntities),
                       &(newDtd->pool),
                       &(oldDtd->paramEntities)))
      return 0;
  newDtd->paramEntityRead = oldDtd->paramEntityRead;
#endif /* XML_DTD */
 
  newDtd->keepProcessing = oldDtd->keepProcessing;
  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
  newDtd->standalone = oldDtd->standalone;
 
  /* Don't want deep copying for scaffolding */
  newDtd->in_eldecl = oldDtd->in_eldecl;
  newDtd->scaffold = oldDtd->scaffold;
  newDtd->contentStringLen = oldDtd->contentStringLen;
  newDtd->scaffSize = oldDtd->scaffSize;
  newDtd->scaffLevel = oldDtd->scaffLevel;
  newDtd->scaffIndex = oldDtd->scaffIndex;
 
  return 1;
}  /* End dtdCopy */

References ELEMENT_TYPE::allocDefaultAtts, DTD::attributeIds, DTD::contentStringLen, copyEntityTable(), ELEMENT_TYPE::defaultAtts, DTD::defaultPrefix, DTD::elementTypes, DTD::generalEntities, hashTableIterInit(), hashTableIterNext(), DTD::hasParamEntityRefs, DEFAULT_ATTRIBUTE::id, ELEMENT_TYPE::idAtt, DTD::in_eldecl, DEFAULT_ATTRIBUTE::isCdata, DTD::keepProcessing, lookup(), attribute_id::maybeTokenized, ms, prefix::name, attribute_id::name, ELEMENT_TYPE::name, G4InuclParticleNames::name(), ELEMENT_TYPE::nDefaultAtts, DTD::pool, poolAppendChar, poolCopyString(), attribute_id::prefix, ELEMENT_TYPE::prefix, DTD::prefixes, DTD::scaffIndex, DTD::scaffLevel, DTD::scaffold, DTD::scaffSize, DTD::standalone, DEFAULT_ATTRIBUTE::value, XML_T, and attribute_id::xmlns.

Referenced by XML_ExternalEntityParserCreate().

◆ dtdCreate()

static DTD * dtdCreate ( const XML_Memory_Handling_Suite * ms )

static

Definition at line 5651 of file xmlparse.cc.

{
  DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
  if (p == NULL)
    return p;
  poolInit(&(p->pool), ms);
  poolInit(&(p->entityValuePool), ms);
  hashTableInit(&(p->generalEntities), ms);
  hashTableInit(&(p->elementTypes), ms);
  hashTableInit(&(p->attributeIds), ms);
  hashTableInit(&(p->prefixes), ms);
#ifdef XML_DTD
  p->paramEntityRead = XML_FALSE;
  hashTableInit(&(p->paramEntities), ms);
#endif /* XML_DTD */
  p->defaultPrefix.name = NULL;
  p->defaultPrefix.binding = NULL;
 
  p->in_eldecl = XML_FALSE;
  p->scaffIndex = NULL;
  p->scaffold = NULL;
  p->scaffLevel = 0;
  p->scaffSize = 0;
  p->scaffCount = 0;
  p->contentStringLen = 0;
 
  p->keepProcessing = XML_TRUE;
  p->hasParamEntityRefs = XML_FALSE;
  p->standalone = XML_FALSE;
  return p;
}

References DTD::attributeIds, prefix::binding, DTD::contentStringLen, DTD::defaultPrefix, DTD::elementTypes, DTD::entityValuePool, DTD::generalEntities, hashTableInit(), DTD::hasParamEntityRefs, DTD::in_eldecl, DTD::keepProcessing, ms, prefix::name, DTD::pool, poolInit(), DTD::prefixes, DTD::scaffCount, DTD::scaffIndex, DTD::scaffLevel, DTD::scaffold, DTD::scaffSize, DTD::standalone, XML_FALSE, and XML_TRUE.

Referenced by parserCreate().

◆ dtdDestroy()

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

static

Definition at line 5726 of file xmlparse.cc.

{
  HASH_TABLE_ITER iter;
  hashTableIterInit(&iter, &(p->elementTypes));
  for (;;) {
    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
    if (!e)
      break;
    if (e->allocDefaultAtts != 0)
      ms->free_fcn(e->defaultAtts);
  }
  hashTableDestroy(&(p->generalEntities));
#ifdef XML_DTD
  hashTableDestroy(&(p->paramEntities));
#endif /* XML_DTD */
  hashTableDestroy(&(p->elementTypes));
  hashTableDestroy(&(p->attributeIds));
  hashTableDestroy(&(p->prefixes));
  poolDestroy(&(p->pool));
  poolDestroy(&(p->entityValuePool));
  if (isDocEntity) {
    ms->free_fcn(p->scaffIndex);
    ms->free_fcn(p->scaffold);
  }
  ms->free_fcn(p);
}

References ELEMENT_TYPE::allocDefaultAtts, DTD::attributeIds, ELEMENT_TYPE::defaultAtts, DTD::elementTypes, DTD::entityValuePool, DTD::generalEntities, hashTableDestroy(), hashTableIterInit(), hashTableIterNext(), ms, DTD::pool, poolDestroy(), DTD::prefixes, DTD::scaffIndex, and DTD::scaffold.

Referenced by XML_ParserFree().

◆ dtdReset()

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

static

Definition at line 5684 of file xmlparse.cc.

{
  HASH_TABLE_ITER iter;
  hashTableIterInit(&iter, &(p->elementTypes));
  for (;;) {
    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
    if (!e)
      break;
    if (e->allocDefaultAtts != 0)
      ms->free_fcn(e->defaultAtts);
  }
  hashTableClear(&(p->generalEntities));
#ifdef XML_DTD
  p->paramEntityRead = XML_FALSE;
  hashTableClear(&(p->paramEntities));
#endif /* XML_DTD */
  hashTableClear(&(p->elementTypes));
  hashTableClear(&(p->attributeIds));
  hashTableClear(&(p->prefixes));
  poolClear(&(p->pool));
  poolClear(&(p->entityValuePool));
  p->defaultPrefix.name = NULL;
  p->defaultPrefix.binding = NULL;
 
  p->in_eldecl = XML_FALSE;
 
  ms->free_fcn(p->scaffIndex);
  p->scaffIndex = NULL;
  ms->free_fcn(p->scaffold);
  p->scaffold = NULL;
 
  p->scaffLevel = 0;
  p->scaffSize = 0;
  p->scaffCount = 0;
  p->contentStringLen = 0;
 
  p->keepProcessing = XML_TRUE;
  p->hasParamEntityRefs = XML_FALSE;
  p->standalone = XML_FALSE;
}

References ELEMENT_TYPE::allocDefaultAtts, DTD::attributeIds, prefix::binding, DTD::contentStringLen, ELEMENT_TYPE::defaultAtts, DTD::defaultPrefix, DTD::elementTypes, DTD::entityValuePool, DTD::generalEntities, hashTableClear(), hashTableIterInit(), hashTableIterNext(), DTD::hasParamEntityRefs, DTD::in_eldecl, DTD::keepProcessing, ms, prefix::name, DTD::pool, poolClear(), DTD::prefixes, DTD::scaffCount, DTD::scaffIndex, DTD::scaffLevel, DTD::scaffold, DTD::scaffSize, DTD::standalone, XML_FALSE, and XML_TRUE.

Referenced by XML_ParserReset().

◆ epilogProcessor()

static enum XML_Error PTRCALL epilogProcessor	(	XML_Parser	parser,
		const char *	s,
		const char *	end,
		const char **	nextPtr
	)

static

Definition at line 4734 of file xmlparse.cc.

{
  processor = epilogProcessor;
  eventPtr = s;
  for (;;) {
    const char *next = NULL;
    int tok = XmlPrologTok(encoding, s, end, &next);
    eventEndPtr = next;
    switch (tok) {
    /* report partial linebreak - it might be the last token */
    case -XML_TOK_PROLOG_S:
      if (defaultHandler) {
        reportDefault(parser, encoding, s, next);
        if (ps_parsing == XML_FINISHED)
          return XML_ERROR_ABORTED;
      }
      *nextPtr = next;
      return XML_ERROR_NONE;
    case XML_TOK_NONE:
      *nextPtr = s;
      return XML_ERROR_NONE;
    case XML_TOK_PROLOG_S:
      if (defaultHandler)
        reportDefault(parser, encoding, s, next);
      break;
    case XML_TOK_PI:
      if (!reportProcessingInstruction(parser, encoding, s, next))
        return XML_ERROR_NO_MEMORY;
      break;
    case XML_TOK_COMMENT:
      if (!reportComment(parser, encoding, s, next))
        return XML_ERROR_NO_MEMORY;
      break;
    case XML_TOK_INVALID:
      eventPtr = next;
      return XML_ERROR_INVALID_TOKEN;
    case XML_TOK_PARTIAL:
      if (!ps_finalBuffer) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_UNCLOSED_TOKEN;
    case XML_TOK_PARTIAL_CHAR:
      if (!ps_finalBuffer) {
        *nextPtr = s;
        return XML_ERROR_NONE;
      }
      return XML_ERROR_PARTIAL_CHAR;
    default:
      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
    }
    eventPtr = s = next;
    switch (ps_parsing) {
    case XML_SUSPENDED:
      *nextPtr = next;
      return XML_ERROR_NONE;
    case XML_FINISHED:
      return XML_ERROR_ABORTED;
    default: ;
    }
  }
}

References defaultHandler, epilogProcessor, eventEndPtr, eventPtr, geant4_check_module_cycles::parser, processor, ps_finalBuffer, ps_parsing, reportComment(), reportDefault(), reportProcessingInstruction(), s, XML_ERROR_ABORTED, XML_ERROR_INVALID_TOKEN, XML_ERROR_JUNK_AFTER_DOC_ELEMENT, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_PARTIAL_CHAR, XML_ERROR_UNCLOSED_TOKEN, XML_FINISHED, XML_SUSPENDED, XML_TOK_COMMENT, XML_TOK_INVALID, XML_TOK_NONE, XML_TOK_PARTIAL, XML_TOK_PARTIAL_CHAR, XML_TOK_PI, XML_TOK_PROLOG_S, and XmlPrologTok.

◆ errorProcessor()

static enum XML_Error PTRCALL errorProcessor	(	XML_Parser	parser,
		const char *	s,
		const char *	end,
		const char **	nextPtr
	)

static

Definition at line 4919 of file xmlparse.cc.

{
  return errorCode;
}

References errorCode.

◆ externalEntityContentProcessor()

static enum XML_Error PTRCALL externalEntityContentProcessor	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 2222 of file xmlparse.cc.

{
  enum XML_Error result = doContent(parser, 1, encoding, start, end,
                                    endPtr, (XML_Bool)!ps_finalBuffer);
  if (result == XML_ERROR_NONE) {
    if (!storeRawNames(parser))
      return XML_ERROR_NO_MEMORY;
  }
  return result;
}

References doContent(), geant4_check_module_cycles::parser, ps_finalBuffer, storeRawNames(), XML_ERROR_NO_MEMORY, and XML_ERROR_NONE.

◆ externalEntityInitProcessor()

static enum XML_Error PTRCALL externalEntityInitProcessor	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 2121 of file xmlparse.cc.

{
  enum XML_Error result = initializeEncoding(parser);
  if (result != XML_ERROR_NONE)
    return result;
  processor = externalEntityInitProcessor2;
  return externalEntityInitProcessor2(parser, start, end, endPtr);
}

References externalEntityInitProcessor2, initializeEncoding(), geant4_check_module_cycles::parser, processor, and XML_ERROR_NONE.

◆ externalEntityInitProcessor2()

static enum XML_Error PTRCALL externalEntityInitProcessor2	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 2134 of file xmlparse.cc.

{
  const char *next = start; /* XmlContentTok doesn't always set the last arg */
  int tok = XmlContentTok(encoding, start, end, &next);
  switch (tok) {
  case XML_TOK_BOM:
    /* If we are at the end of the buffer, this would cause the next stage,
       i.e. externalEntityInitProcessor3, to pass control directly to
       doContent (by detecting XML_TOK_NONE) without processing any xml text
       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
    */
    if (next == end && !ps_finalBuffer) {
      *endPtr = next;
      return XML_ERROR_NONE;
    }
    start = next;
    break;
  case XML_TOK_PARTIAL:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    eventPtr = start;
    return XML_ERROR_UNCLOSED_TOKEN;
  case XML_TOK_PARTIAL_CHAR:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    eventPtr = start;
    return XML_ERROR_PARTIAL_CHAR;
  }
  processor = externalEntityInitProcessor3;
  return externalEntityInitProcessor3(parser, start, end, endPtr);
}

References eventPtr, externalEntityInitProcessor3, geant4_check_module_cycles::parser, processor, ps_finalBuffer, XML_ERROR_NONE, XML_ERROR_PARTIAL_CHAR, XML_ERROR_UNCLOSED_TOKEN, XML_TOK_BOM, XML_TOK_PARTIAL, XML_TOK_PARTIAL_CHAR, and XmlContentTok.

◆ externalEntityInitProcessor3()

static enum XML_Error PTRCALL externalEntityInitProcessor3	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

static

Definition at line 2174 of file xmlparse.cc.

{
  int tok;
  const char *next = start; /* XmlContentTok doesn't always set the last arg */
  eventPtr = start;
  tok = XmlContentTok(encoding, start, end, &next);
  eventEndPtr = next;
 
  switch (tok) {
  case XML_TOK_XML_DECL:
    {
      enum XML_Error result;
      result = processXmlDecl(parser, 1, start, next);
      if (result != XML_ERROR_NONE)
        return result;
      switch (ps_parsing) {
      case XML_SUSPENDED:
        *endPtr = next;
        return XML_ERROR_NONE;
      case XML_FINISHED:
        return XML_ERROR_ABORTED;
      default:
        start = next;
      }
    }
    break;
  case XML_TOK_PARTIAL:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    return XML_ERROR_UNCLOSED_TOKEN;
  case XML_TOK_PARTIAL_CHAR:
    if (!ps_finalBuffer) {
      *endPtr = start;
      return XML_ERROR_NONE;
    }
    return XML_ERROR_PARTIAL_CHAR;
  }
  processor = externalEntityContentProcessor;
  tagLevel = 1;
  return externalEntityContentProcessor(parser, start, end, endPtr);
}

References eventEndPtr, eventPtr, externalEntityContentProcessor, geant4_check_module_cycles::parser, processor, processXmlDecl(), ps_finalBuffer, ps_parsing, tagLevel, XML_ERROR_ABORTED, XML_ERROR_NONE, XML_ERROR_PARTIAL_CHAR, XML_ERROR_UNCLOSED_TOKEN, XML_FINISHED, XML_SUSPENDED, XML_TOK_PARTIAL, XML_TOK_PARTIAL_CHAR, XML_TOK_XML_DECL, and XmlContentTok.

◆ generate_hash_secret_salt()

static unsigned long generate_hash_secret_salt ( void )

static

Definition at line 700 of file xmlparse.cc.

{
  unsigned int seed = time(NULL) % UINT_MAX;
  srand(seed);
  return rand();
}

Referenced by startParsing().

◆ getAttributeId()

static ATTRIBUTE_ID * getAttributeId	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	start,
		const char *	end
	)

static

Definition at line 5436 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  ATTRIBUTE_ID *id;
  const XML_Char *name;
  if (!poolAppendChar(&dtd->pool, XML_T('\0')))
    return NULL;
  name = poolStoreString(&dtd->pool, enc, start, end);
  if (!name)
    return NULL;
  /* skip quotation mark - its storage will be re-used (like in name[-1]) */
  ++name;
  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));
  if (!id)
    return NULL;
  if (id->name != name)
    poolDiscard(&dtd->pool);
  else {
    poolFinish(&dtd->pool);
    if (!ns)
      ;
    else if (name[0] == XML_T(ASCII_x)
        && name[1] == XML_T(ASCII_m)
        && name[2] == XML_T(ASCII_l)
        && name[3] == XML_T(ASCII_n)
        && name[4] == XML_T(ASCII_s)
        && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
      if (name[5] == XML_T('\0'))
        id->prefix = &dtd->defaultPrefix;
      else
        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6, sizeof(PREFIX));
      id->xmlns = XML_TRUE;
    }
    else {
      int i;
      for (i = 0; name[i]; i++) {
        /* attributes without prefix are *not* in the default namespace */
        if (name[i] == XML_T(ASCII_COLON)) {
          int j;
          for (j = 0; j < i; j++) {
            if (!poolAppendChar(&dtd->pool, name[j]))
              return NULL;
          }
          if (!poolAppendChar(&dtd->pool, XML_T('\0')))
            return NULL;
          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
                                        sizeof(PREFIX));
          if (id->prefix->name == poolStart(&dtd->pool))
            poolFinish(&dtd->pool);
          else
            poolDiscard(&dtd->pool);
          break;
        }
      }
    }
  }
  return id;
}

References _dtd, ASCII_COLON, ASCII_l, ASCII_m, ASCII_n, ASCII_s, ASCII_x, DTD::attributeIds, DTD::defaultPrefix, lookup(), prefix::name, attribute_id::name, G4InuclParticleNames::name(), ns, geant4_check_module_cycles::parser, DTD::pool, poolAppendChar, poolDiscard, poolFinish, poolStart, poolStoreString(), attribute_id::prefix, DTD::prefixes, XML_T, and XML_TRUE.

Referenced by doProlog(), and storeAtts().

◆ getContext()

static const XML_Char * getContext ( XML_Parser parser )

static

Definition at line 5499 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  HASH_TABLE_ITER iter;
  XML_Bool needSep = XML_FALSE;
 
  if (dtd->defaultPrefix.binding) {
    int i;
    int len;
    if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
      return NULL;
    len = dtd->defaultPrefix.binding->uriLen;
    if (namespaceSeparator)
      len--;
    for (i = 0; i < len; i++)
      if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))
        return NULL;
    needSep = XML_TRUE;
  }
 
  hashTableIterInit(&iter, &(dtd->prefixes));
  for (;;) {
    int i;
    int len;
    const XML_Char *s;
    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
    if (!prefix)
      break;
    if (!prefix->binding)
      continue;
    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
      return NULL;
    for (s = prefix->name; *s; s++)
      if (!poolAppendChar(&tempPool, *s))
        return NULL;
    if (!poolAppendChar(&tempPool, XML_T(ASCII_EQUALS)))
      return NULL;
    len = prefix->binding->uriLen;
    if (namespaceSeparator)
      len--;
    for (i = 0; i < len; i++)
      if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
        return NULL;
    needSep = XML_TRUE;
  }
 
 
  hashTableIterInit(&iter, &(dtd->generalEntities));
  for (;;) {
    const XML_Char *s;
    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
    if (!e)
      break;
    if (!e->open)
      continue;
    if (needSep && !poolAppendChar(&tempPool, CONTEXT_SEP))
      return NULL;
    for (s = e->name; *s; s++)
      if (!poolAppendChar(&tempPool, *s))
        return 0;
    needSep = XML_TRUE;
  }
 
  if (!poolAppendChar(&tempPool, XML_T('\0')))
    return NULL;
  return tempPool.start;
}

References _dtd, ASCII_EQUALS, prefix::binding, CONTEXT_SEP, DTD::defaultPrefix, DTD::generalEntities, hashTableIterInit(), hashTableIterNext(), prefix::name, ENTITY::name, namespaceSeparator, ENTITY::open, poolAppendChar, DTD::prefixes, s, tempPool, binding::uri, binding::uriLen, XML_FALSE, XML_T, and XML_TRUE.

Referenced by doContent().

◆ getElementType()

static ELEMENT_TYPE * getElementType	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	ptr,
		const char *	end
	)

static

Definition at line 6387 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
  ELEMENT_TYPE *ret;
 
  if (!name)
    return NULL;
  ret = (ELEMENT_TYPE *) lookup(parser, &dtd->elementTypes, name, sizeof(ELEMENT_TYPE));
  if (!ret)
    return NULL;
  if (ret->name != name)
    poolDiscard(&dtd->pool);
  else {
    poolFinish(&dtd->pool);
    if (!setElementTypePrefix(parser, ret))
      return NULL;
  }
  return ret;
}

References _dtd, DTD::elementTypes, lookup(), ELEMENT_TYPE::name, G4InuclParticleNames::name(), geant4_check_module_cycles::parser, DTD::pool, poolDiscard, poolFinish, poolStoreString(), and setElementTypePrefix().

Referenced by doProlog().

◆ handleUnknownEncoding()

static enum XML_Error handleUnknownEncoding	(	XML_Parser	parser,
		const XML_Char *	encodingName
	)

static

Definition at line 3514 of file xmlparse.cc.

{
  if (unknownEncodingHandler) {
    XML_Encoding info;
    int i;
    for (i = 0; i < 256; i++)
      info.map[i] = -1;
    info.convert = NULL;
    info.data = NULL;
    info.release = NULL;
    if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName,
                               &info)) {
      ENCODING *enc;
      unknownEncodingMem = MALLOC(XmlSizeOfUnknownEncoding());
      if (!unknownEncodingMem) {
        if (info.release)
          info.release(info.data);
        return XML_ERROR_NO_MEMORY;
      }
      enc = (ns
             ? XmlInitUnknownEncodingNS
             : XmlInitUnknownEncoding)(unknownEncodingMem,
                                       info.map,
                                       info.convert,
                                       info.data);
      if (enc) {
        unknownEncodingData = info.data;
        unknownEncodingRelease = info.release;
        encoding = enc;
        return XML_ERROR_NONE;
      }
    }
    if (info.release != NULL)
      info.release(info.data);
  }
  return XML_ERROR_UNKNOWN_ENCODING;
}

References XML_Encoding::data, MALLOC, XML_Encoding::map, ns, unknownEncodingData, unknownEncodingHandler, unknownEncodingHandlerData, unknownEncodingMem, unknownEncodingRelease, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_UNKNOWN_ENCODING, XmlInitUnknownEncoding(), XmlInitUnknownEncodingNS, and XmlSizeOfUnknownEncoding().

Referenced by initializeEncoding(), and processXmlDecl().

◆ hash()

static unsigned long FASTCALL hash	(	XML_Parser	parser,
		KEY	s
	)

static

Definition at line 5967 of file xmlparse.cc.

{
  unsigned long h = hash_secret_salt;
  while (*s)
    h = CHAR_HASH(h, *s++);
  return h;
}

References CHAR_HASH, hash_secret_salt, and s.

Referenced by G4VtkSceneHandler::AddPrimitive(), G4VtkSceneHandler::AddPrimitiveTensorGlyph(), G4ITReaction::GetHash(), lookup(), std::hash< G4Polyhedron >::operator()(), std::hash< G4VisAttributes >::operator()(), and storeAtts().

◆ hashTableClear()

static void FASTCALL hashTableClear ( HASH_TABLE * table )

static

Definition at line 6055 of file xmlparse.cc.

{
  size_t i;
  for (i = 0; i < table->size; i++) {
    table->mem->free_fcn(table->v[i]);
    table->v[i] = NULL;
  }
  table->used = 0;
}

References XML_Memory_Handling_Suite::free_fcn, HASH_TABLE::mem, HASH_TABLE::size, HASH_TABLE::used, and HASH_TABLE::v.

Referenced by dtdReset().

◆ hashTableDestroy()

static void FASTCALL hashTableDestroy ( HASH_TABLE * table )

static

Definition at line 6066 of file xmlparse.cc.

{
  size_t i;
  for (i = 0; i < table->size; i++)
    table->mem->free_fcn(table->v[i]);
  table->mem->free_fcn(table->v);
}

References XML_Memory_Handling_Suite::free_fcn, HASH_TABLE::mem, HASH_TABLE::size, and HASH_TABLE::v.

Referenced by dtdDestroy().

◆ hashTableInit()

static void FASTCALL hashTableInit	(	HASH_TABLE *	p,
		const XML_Memory_Handling_Suite *	ms
	)

static

Definition at line 6075 of file xmlparse.cc.

{
  p->power = 0;
  p->size = 0;
  p->used = 0;
  p->v = NULL;
  p->mem = ms;
}

References HASH_TABLE::mem, ms, HASH_TABLE::power, HASH_TABLE::size, HASH_TABLE::used, and HASH_TABLE::v.

Referenced by dtdCreate().

◆ hashTableIterInit()

static void FASTCALL hashTableIterInit	(	HASH_TABLE_ITER *	iter,
		const HASH_TABLE *	table
	)

static

Definition at line 6085 of file xmlparse.cc.

{
  iter->p = table->v;
  iter->end = iter->p + table->size;
}

References HASH_TABLE_ITER::end, HASH_TABLE_ITER::p, HASH_TABLE::size, and HASH_TABLE::v.

Referenced by copyEntityTable(), dtdCopy(), dtdDestroy(), dtdReset(), and getContext().

◆ hashTableIterNext()

static NAMED *FASTCALL hashTableIterNext ( HASH_TABLE_ITER * iter )

static

Definition at line 6092 of file xmlparse.cc.

{
  while (iter->p != iter->end) {
    NAMED *tem = *(iter->p)++;
    if (tem)
      return tem;
  }
  return NULL;
}

References HASH_TABLE_ITER::end, and HASH_TABLE_ITER::p.

Referenced by copyEntityTable(), dtdCopy(), dtdDestroy(), dtdReset(), and getContext().

◆ initializeEncoding()

static enum XML_Error initializeEncoding ( XML_Parser parser )

static

Definition at line 3396 of file xmlparse.cc.

{
  const char *s;
#ifdef XML_UNICODE
  char encodingBuf[128];
  if (!protocolEncodingName)
    s = NULL;
  else {
    int i;
    for (i = 0; protocolEncodingName[i]; i++) {
      if (i == sizeof(encodingBuf) - 1
          || (protocolEncodingName[i] & ~0x7f) != 0) {
        encodingBuf[0] = '\0';
        break;
      }
      encodingBuf[i] = (char)protocolEncodingName[i];
    }
    encodingBuf[i] = '\0';
    s = encodingBuf;
  }
#else
  s = protocolEncodingName;
#endif
  if ((ns ? XmlInitEncodingNS : XmlInitEncoding)(&initEncoding, &encoding, s))
    return XML_ERROR_NONE;
  return handleUnknownEncoding(parser, protocolEncodingName);
}

References encoding, handleUnknownEncoding(), initEncoding, ns, geant4_check_module_cycles::parser, protocolEncodingName, s, XML_ERROR_NONE, XmlInitEncoding(), and XmlInitEncodingNS.

Referenced by externalEntityInitProcessor(), and prologInitProcessor().

◆ internalEntityProcessor()

static enum XML_Error PTRCALL internalEntityProcessor	(	XML_Parser	parser,
		const char *	s,
		const char *	end,
		const char **	nextPtr
	)

static

Definition at line 4858 of file xmlparse.cc.

{
  ENTITY *entity;
  const char *textStart, *textEnd;
  const char *next;
  enum XML_Error result;
  OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;
  if (!openEntity)
    return XML_ERROR_UNEXPECTED_STATE;
 
  entity = openEntity->entity;
  textStart = ((char *)entity->textPtr) + entity->processed;
  textEnd = (char *)(entity->textPtr + entity->textLen);
 
#ifdef XML_DTD
  if (entity->is_param) {
    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
                      next, &next, XML_FALSE);
  }
  else
#endif /* XML_DTD */
    result = doContent(parser, openEntity->startTagLevel, internalEncoding,
                       textStart, textEnd, &next, XML_FALSE);
 
  if (result != XML_ERROR_NONE)
    return result;
  else if (textEnd != next && ps_parsing == XML_SUSPENDED) {
    entity->processed = (int)(next - (char *)entity->textPtr);
    return result;
  }
  else {
    entity->open = XML_FALSE;
    openInternalEntities = openEntity->next;
    /* put openEntity back in list of free instances */
    openEntity->next = freeInternalEntities;
    freeInternalEntities = openEntity;
  }
 
#ifdef XML_DTD
  if (entity->is_param) {
    int tok;
    processor = prologProcessor;
    tok = XmlPrologTok(encoding, s, end, &next);
    return doProlog(parser, encoding, s, end, tok, next, nextPtr,
                    (XML_Bool)!ps_finalBuffer);
  }
  else
#endif /* XML_DTD */
  {
    processor = contentProcessor;
    /* see externalEntityContentProcessor vs contentProcessor */
    return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
                     nextPtr, (XML_Bool)!ps_finalBuffer);
  }
}

References contentProcessor, doContent(), doProlog(), open_internal_entity::entity, freeInternalEntities, internalEncoding, ENTITY::is_param, open_internal_entity::next, ENTITY::open, openInternalEntities, parentParser, geant4_check_module_cycles::parser, ENTITY::processed, processor, prologProcessor, ps_finalBuffer, ps_parsing, s, open_internal_entity::startTagLevel, ENTITY::textLen, ENTITY::textPtr, XML_ERROR_NONE, XML_ERROR_UNEXPECTED_STATE, XML_FALSE, XML_SUSPENDED, and XmlPrologTok.

◆ keyeq()

static XML_Bool FASTCALL keyeq	(	KEY	s1,
		KEY	s2
	)

static

Definition at line 5958 of file xmlparse.cc.

{
  for (; *s1 == *s2; s1++, s2++)
    if (*s1 == 0)
      return XML_TRUE;
  return XML_FALSE;
}

References XML_FALSE, and XML_TRUE.

Referenced by lookup().

◆ lookup()

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

static

Definition at line 5976 of file xmlparse.cc.

{
  size_t i;
  if (table->size == 0) {
    size_t tsize;
    if (!createSize)
      return NULL;
    table->power = INIT_POWER;
    /* table->size is a power of 2 */
    table->size = (size_t)1 << INIT_POWER;
    tsize = table->size * sizeof(NAMED *);
    table->v = (NAMED **)table->mem->malloc_fcn(tsize);
    if (!table->v) {
      table->size = 0;
      return NULL;
    }
    memset(table->v, 0, tsize);
    i = hash(parser, name) & ((unsigned long)table->size - 1);
  }
  else {
    unsigned long h = hash(parser, name);
    unsigned long mask = (unsigned long)table->size - 1;
    unsigned char step = 0;
    i = h & mask;
    while (table->v[i]) {
      if (keyeq(name, table->v[i]->name))
        return table->v[i];
      if (!step)
        step = PROBE_STEP(h, mask, table->power);
      i < step ? (i += table->size - step) : (i -= step);
    }
    if (!createSize)
      return NULL;
 
    /* check for overflow (table is half full) */
    if (table->used >> (table->power - 1)) {
      unsigned char newPower = table->power + 1;
      size_t newSize = (size_t)1 << newPower;
      unsigned long newMask = (unsigned long)newSize - 1;
      size_t tsize = newSize * sizeof(NAMED *);
      NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
      if (!newV)
        return NULL;
      memset(newV, 0, tsize);
      for (i = 0; i < table->size; i++)
        if (table->v[i]) {
          unsigned long newHash = hash(parser, table->v[i]->name);
          size_t j = newHash & newMask;
          step = 0;
          while (newV[j]) {
            if (!step)
              step = PROBE_STEP(newHash, newMask, newPower);
            j < step ? (j += newSize - step) : (j -= step);
          }
          newV[j] = table->v[i];
        }
      table->mem->free_fcn(table->v);
      table->v = newV;
      table->power = newPower;
      table->size = newSize;
      i = h & newMask;
      step = 0;
      while (table->v[i]) {
        if (!step)
          step = PROBE_STEP(h, newMask, newPower);
        i < step ? (i += newSize - step) : (i -= step);
      }
    }
  }
  table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
  if (!table->v[i])
    return NULL;
  memset(table->v[i], 0, createSize);
  table->v[i]->name = name;
  (table->used)++;
  return table->v[i];
}

References XML_Memory_Handling_Suite::free_fcn, hash(), INIT_POWER, keyeq(), XML_Memory_Handling_Suite::malloc_fcn, HASH_TABLE::mem, NAMED::name, G4InuclParticleNames::name(), geant4_check_module_cycles::parser, HASH_TABLE::power, PROBE_STEP, HASH_TABLE::size, HASH_TABLE::used, and HASH_TABLE::v.

Referenced by appendAttributeValue(), copyEntityTable(), doContent(), doProlog(), dtdCopy(), getAttributeId(), getElementType(), setContext(), setElementTypePrefix(), storeAtts(), and storeEntityValue().

◆ moveToFreeBindingList()

static void FASTCALL moveToFreeBindingList	(	XML_Parser	parser,
		BINDING *	bindings
	)

static

Definition at line 920 of file xmlparse.cc.

{
  while (bindings) {
    BINDING *b = bindings;
    bindings = bindings->nextTagBinding;
    b->nextTagBinding = freeBindingList;
    freeBindingList = b;
  }
}

References freeBindingList, and binding::nextTagBinding.

Referenced by XML_ParserReset().

◆ nextScaffoldPart()

static int FASTCALL nextScaffoldPart ( XML_Parser parser )

static

Definition at line 6280 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  CONTENT_SCAFFOLD * me;
  int next;
 
  if (!dtd->scaffIndex) {
    dtd->scaffIndex = (int *)MALLOC(groupSize * sizeof(int));
    if (!dtd->scaffIndex)
      return -1;
    dtd->scaffIndex[0] = 0;
  }
 
  if (dtd->scaffCount >= dtd->scaffSize) {
    CONTENT_SCAFFOLD *temp;
    if (dtd->scaffold) {
      temp = (CONTENT_SCAFFOLD *)
        REALLOC(dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
      if (temp == NULL)
        return -1;
      dtd->scaffSize *= 2;
    }
    else {
      temp = (CONTENT_SCAFFOLD *)MALLOC(INIT_SCAFFOLD_ELEMENTS
                                        * sizeof(CONTENT_SCAFFOLD));
      if (temp == NULL)
        return -1;
      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
    }
    dtd->scaffold = temp;
  }
  next = dtd->scaffCount++;
  me = &dtd->scaffold[next];
  if (dtd->scaffLevel) {
    CONTENT_SCAFFOLD *parent = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel-1]];
    if (parent->lastchild) {
      dtd->scaffold[parent->lastchild].nextsib = next;
    }
    if (!parent->childcnt)
      parent->firstchild = next;
    parent->lastchild = next;
    parent->childcnt++;
  }
  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
  return next;
}

References _dtd, CONTENT_SCAFFOLD::childcnt, CONTENT_SCAFFOLD::firstchild, groupSize, INIT_SCAFFOLD_ELEMENTS, CONTENT_SCAFFOLD::lastchild, MALLOC, CONTENT_SCAFFOLD::nextsib, REALLOC, DTD::scaffCount, DTD::scaffIndex, DTD::scaffLevel, DTD::scaffold, and DTD::scaffSize.

Referenced by doProlog().

◆ normalizeLines()

static void FASTCALL normalizeLines ( XML_Char * s )

static

Definition at line 5260 of file xmlparse.cc.

{
  XML_Char *p;
  for (;; s++) {
    if (*s == XML_T('\0'))
      return;
    if (*s == 0xD)
      break;
  }
  p = s;
  do {
    if (*s == 0xD) {
      *p++ = 0xA;
      if (*++s == 0xA)
        s++;
    }
    else
      *p++ = *s++;
  } while (*s);
  *p = XML_T('\0');
}

References s, and XML_T.

Referenced by reportComment(), and reportProcessingInstruction().

◆ normalizePublicId()

static void FASTCALL normalizePublicId ( XML_Char * s )

static

Definition at line 5629 of file xmlparse.cc.

{
  XML_Char *p = publicId;
  XML_Char *s;
  for (s = publicId; *s; s++) {
    switch (*s) {
    case 0x20:
    case 0xD:
    case 0xA:
      if (p != publicId && p[-1] != 0x20)
        *p++ = 0x20;
      break;
    default:
      *p++ = *s;
    }
  }
  if (p != publicId && p[-1] == 0x20)
    --p;
  *p = XML_T('\0');
}

References s, and XML_T.

Referenced by doProlog().

◆ parserCreate()

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

static

Definition at line 731 of file xmlparse.cc.

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

References _dtd, ASCII_EXCL, attInfo, atts, attsSize, buffer, bufferLim, dataBuf, dataBufEnd, dtdCreate(), FREE, free, XML_Memory_Handling_Suite::free_fcn, freeBindingList, freeInternalEntities, freeTagList, groupConnector, groupSize, INIT_ATTS_SIZE, INIT_DATA_BUF_SIZE, internalEncoding, MALLOC, XML_Memory_Handling_Suite::malloc_fcn, namespaceSeparator, ns, ns_triplets, nsAtts, nsAttsPower, nsAttsVersion, geant4_check_module_cycles::parser, parserInit(), poolInit(), protocolEncodingName, XML_Memory_Handling_Suite::realloc_fcn, temp2Pool, tempPool, unknownEncodingHandler, unknownEncodingHandlerData, XML_FALSE, XML_ParserFree(), XML_TRUE, XmlGetInternalEncoding, and XmlGetInternalEncodingNS.

Referenced by XML_ExternalEntityParserCreate(), and XML_ParserCreate_MM().

◆ parserInit()

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

static

Definition at line 846 of file xmlparse.cc.

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

References attlistDeclHandler, buffer, bufferEnd, bufferPtr, characterDataHandler, commentHandler, curBase, declAttributeId, declAttributeIsCdata, declAttributeIsId, declAttributeType, declElementType, declEntity, declNotationName, declNotationPublicId, defaultExpandInternalEntities, defaultHandler, doctypeName, doctypePubid, doctypeSysid, elementDeclHandler, endCdataSectionHandler, endDoctypeDeclHandler, endElementHandler, endNamespaceDeclHandler, entityDeclHandler, errorCode, eventEndPtr, eventPtr, externalEntityRefHandler, externalEntityRefHandlerArg, handlerArg, hash_secret_salt, inheritedBindings, initEncoding, notationDeclHandler, notStandaloneHandler, nSpecifiedAtts, openInternalEntities, parentParser, parseEndByteIndex, parseEndPtr, geant4_check_module_cycles::parser, poolCopyString(), positionPtr, processingInstructionHandler, processor, prologInitProcessor, prologState, protocolEncodingName, ps_parsing, skippedEntityHandler, startCdataSectionHandler, startDoctypeDeclHandler, startElementHandler, startNamespaceDeclHandler, tagLevel, tagStack, tempPool, unknownEncodingData, unknownEncodingMem, unknownEncodingRelease, unparsedEntityDeclHandler, userData, XML_ERROR_NONE, XML_FALSE, XML_INITIALIZED, XML_PARAM_ENTITY_PARSING_NEVER, XML_TRUE, xmlDeclHandler, XmlInitEncoding(), and XmlPrologStateInit().

Referenced by parserCreate(), and XML_ParserReset().

◆ poolAppend()

static XML_Char * poolAppend	(	STRING_POOL *	pool,
		const ENCODING *	enc,
		const char *	ptr,
		const char *	end
	)

static

Definition at line 6151 of file xmlparse.cc.

{
  if (!pool->ptr && !poolGrow(pool))
    return NULL;
  for (;;) {
    XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
    if (ptr == end)
      break;
    if (!poolGrow(pool))
      return NULL;
  }
  return pool->start;
}

References STRING_POOL::end, poolGrow(), STRING_POOL::ptr, STRING_POOL::start, and XmlConvert.

Referenced by appendAttributeValue(), doProlog(), poolStoreString(), and storeEntityValue().

◆ poolAppendString()

static const XML_Char *FASTCALL poolAppendString	(	STRING_POOL *	pool,
		const XML_Char *	s
	)

static

Definition at line 6193 of file xmlparse.cc.

{
  while (*s) {
    if (!poolAppendChar(pool, *s))
      return NULL;
    s++;
  }
  return pool->start;
}

References poolAppendChar, s, and STRING_POOL::start.

Referenced by doProlog().

◆ poolClear()

static void FASTCALL poolClear ( STRING_POOL * pool )

static

Definition at line 6114 of file xmlparse.cc.

{
  if (!pool->freeBlocks)
    pool->freeBlocks = pool->blocks;
  else {
    BLOCK *p = pool->blocks;
    while (p) {
      BLOCK *tem = p->next;
      p->next = pool->freeBlocks;
      pool->freeBlocks = p;
      p = tem;
    }
  }
  pool->blocks = NULL;
  pool->start = NULL;
  pool->ptr = NULL;
  pool->end = NULL;
}

References STRING_POOL::blocks, STRING_POOL::end, STRING_POOL::freeBlocks, block::next, STRING_POOL::ptr, and STRING_POOL::start.

Referenced by doContent(), doProlog(), dtdReset(), processXmlDecl(), reportComment(), reportProcessingInstruction(), and XML_ParserReset().

◆ poolCopyString()

static const XML_Char *FASTCALL poolCopyString	(	STRING_POOL *	pool,
		const XML_Char *	s
	)

static

Definition at line 6167 of file xmlparse.cc.

{
  do {
    if (!poolAppendChar(pool, *s))
      return NULL;
  } while (*s++);
  s = pool->start;
  poolFinish(pool);
  return s;
}

References poolAppendChar, poolFinish, s, and STRING_POOL::start.

Referenced by copyEntityTable(), dtdCopy(), parserInit(), setContext(), storeAtts(), XML_SetBase(), and XML_SetEncoding().

◆ poolCopyStringN()

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

static

Definition at line 6179 of file xmlparse.cc.

{
  if (!pool->ptr && !poolGrow(pool))
    return NULL;
  for (; n > 0; --n, s++) {
    if (!poolAppendChar(pool, *s))
      return NULL;
  }
  s = pool->start;
  poolFinish(pool);
  return s;
}

References CLHEP::detail::n, poolAppendChar, poolFinish, poolGrow(), STRING_POOL::ptr, s, and STRING_POOL::start.

Referenced by copyEntityTable().

◆ poolDestroy()

static void FASTCALL poolDestroy ( STRING_POOL * pool )

static

Definition at line 6134 of file xmlparse.cc.

{
  BLOCK *p = pool->blocks;
  while (p) {
    BLOCK *tem = p->next;
    pool->mem->free_fcn(p);
    p = tem;
  }
  p = pool->freeBlocks;
  while (p) {
    BLOCK *tem = p->next;
    pool->mem->free_fcn(p);
    p = tem;
  }
}

References STRING_POOL::blocks, XML_Memory_Handling_Suite::free_fcn, STRING_POOL::freeBlocks, STRING_POOL::mem, and block::next.

Referenced by dtdDestroy(), and XML_ParserFree().

◆ poolGrow()

static XML_Bool FASTCALL poolGrow ( STRING_POOL * pool )

static

Definition at line 6216 of file xmlparse.cc.

{
  if (pool->freeBlocks) {
    if (pool->start == 0) {
      pool->blocks = pool->freeBlocks;
      pool->freeBlocks = pool->freeBlocks->next;
      pool->blocks->next = NULL;
      pool->start = pool->blocks->s;
      pool->end = pool->start + pool->blocks->size;
      pool->ptr = pool->start;
      return XML_TRUE;
    }
    if (pool->end - pool->start < pool->freeBlocks->size) {
      BLOCK *tem = pool->freeBlocks->next;
      pool->freeBlocks->next = pool->blocks;
      pool->blocks = pool->freeBlocks;
      pool->freeBlocks = tem;
      memcpy(pool->blocks->s, pool->start,
             (pool->end - pool->start) * sizeof(XML_Char));
      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
      pool->start = pool->blocks->s;
      pool->end = pool->start + pool->blocks->size;
      return XML_TRUE;
    }
  }
  if (pool->blocks && pool->start == pool->blocks->s) {
    int blockSize = (int)(pool->end - pool->start)*2;
    BLOCK *temp = (BLOCK *)
      pool->mem->realloc_fcn(pool->blocks,
                             (offsetof(BLOCK, s)
                              + blockSize * sizeof(XML_Char)));
    if (temp == NULL)
      return XML_FALSE;
    pool->blocks = temp;
    pool->blocks->size = blockSize;
    pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
    pool->start = pool->blocks->s;
    pool->end = pool->start + blockSize;
  }
  else {
    BLOCK *tem;
    int blockSize = (int)(pool->end - pool->start);
    if (blockSize < INIT_BLOCK_SIZE)
      blockSize = INIT_BLOCK_SIZE;
    else
      blockSize *= 2;
    tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)
                                        + blockSize * sizeof(XML_Char));
    if (!tem)
      return XML_FALSE;
    tem->size = blockSize;
    tem->next = pool->blocks;
    pool->blocks = tem;
    if (pool->ptr != pool->start)
      memcpy(tem->s, pool->start,
             (pool->ptr - pool->start) * sizeof(XML_Char));
    pool->ptr = tem->s + (pool->ptr - pool->start);
    pool->start = tem->s;
    pool->end = tem->s + blockSize;
  }
  return XML_TRUE;
}

References STRING_POOL::blocks, STRING_POOL::end, STRING_POOL::freeBlocks, INIT_BLOCK_SIZE, XML_Memory_Handling_Suite::malloc_fcn, STRING_POOL::mem, block::next, STRING_POOL::ptr, XML_Memory_Handling_Suite::realloc_fcn, block::s, s, block::size, STRING_POOL::start, XML_FALSE, and XML_TRUE.

Referenced by poolAppend(), poolCopyStringN(), poolStoreString(), and storeEntityValue().

◆ poolInit()

static void FASTCALL poolInit	(	STRING_POOL *	pool,
		const XML_Memory_Handling_Suite *	ms
	)

static

Definition at line 6103 of file xmlparse.cc.

{
  pool->blocks = NULL;
  pool->freeBlocks = NULL;
  pool->start = NULL;
  pool->ptr = NULL;
  pool->end = NULL;
  pool->mem = ms;
}

References STRING_POOL::blocks, STRING_POOL::end, STRING_POOL::freeBlocks, STRING_POOL::mem, ms, STRING_POOL::ptr, and STRING_POOL::start.

Referenced by dtdCreate(), and parserCreate().

◆ poolStoreString()

static XML_Char * poolStoreString	(	STRING_POOL *	pool,
		const ENCODING *	enc,
		const char *	ptr,
		const char *	end
	)

static

Definition at line 6204 of file xmlparse.cc.

{
  if (!poolAppend(pool, enc, ptr, end))
    return NULL;
  if (pool->ptr == pool->end && !poolGrow(pool))
    return NULL;
  *(pool->ptr)++ = 0;
  return pool->start;
}

References STRING_POOL::end, poolAppend(), poolGrow(), STRING_POOL::ptr, and STRING_POOL::start.

Referenced by appendAttributeValue(), doContent(), doProlog(), getAttributeId(), getElementType(), processXmlDecl(), reportComment(), reportProcessingInstruction(), storeAtts(), and storeEntityValue().

◆ processInternalEntity()

static enum XML_Error processInternalEntity	(	XML_Parser	parser,
		ENTITY *	entity,
		XML_Bool	betweenDecl
	)

static

Definition at line 4801 of file xmlparse.cc.

{
  const char *textStart, *textEnd;
  const char *next;
  enum XML_Error result;
  OPEN_INTERNAL_ENTITY *openEntity;
 
  if (freeInternalEntities) {
    openEntity = freeInternalEntities;
    freeInternalEntities = openEntity->next;
  }
  else {
    openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));
    if (!openEntity)
      return XML_ERROR_NO_MEMORY;
  }
  entity->open = XML_TRUE;
  entity->processed = 0;
  openEntity->next = openInternalEntities;
  openInternalEntities = openEntity;
  openEntity->entity = entity;
  openEntity->startTagLevel = tagLevel;
  openEntity->betweenDecl = betweenDecl;
  openEntity->internalEventPtr = NULL;
  openEntity->internalEventEndPtr = NULL;
  textStart = (char *)entity->textPtr;
  textEnd = (char *)(entity->textPtr + entity->textLen);
 
#ifdef XML_DTD
  if (entity->is_param) {
    int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);
    result = doProlog(parser, internalEncoding, textStart, textEnd, tok,
                      next, &next, XML_FALSE);
  }
  else
#endif /* XML_DTD */
    result = doContent(parser, tagLevel, internalEncoding, textStart,
                       textEnd, &next, XML_FALSE);
 
  if (result == XML_ERROR_NONE) {
    if (textEnd != next && ps_parsing == XML_SUSPENDED) {
      entity->processed = (int)(next - textStart);
      processor = internalEntityProcessor;
    }
    else {
      entity->open = XML_FALSE;
      openInternalEntities = openEntity->next;
      /* put openEntity back in list of free instances */
      openEntity->next = freeInternalEntities;
      freeInternalEntities = openEntity;
    }
  }
  return result;
}

References open_internal_entity::betweenDecl, doContent(), doProlog(), open_internal_entity::entity, freeInternalEntities, internalEncoding, internalEntityProcessor, open_internal_entity::internalEventEndPtr, open_internal_entity::internalEventPtr, ENTITY::is_param, MALLOC, open_internal_entity::next, ENTITY::open, openInternalEntities, geant4_check_module_cycles::parser, ENTITY::processed, processor, ps_parsing, open_internal_entity::startTagLevel, tagLevel, ENTITY::textLen, ENTITY::textPtr, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_FALSE, XML_SUSPENDED, XML_TRUE, and XmlPrologTok.

Referenced by doContent(), and doProlog().

◆ Processor()

enum XML_Error PTRCALL Processor	(	XML_Parser	parser,
		const char *	start,
		const char *	end,
		const char **	endPtr
	)

◆ processXmlDecl()

static enum XML_Error processXmlDecl	(	XML_Parser	parser,
		int	isGeneralTextEntity,
		const char *	s,
		const char *	next
	)

static

Definition at line 3425 of file xmlparse.cc.

{
  const char *encodingName = NULL;
  const XML_Char *storedEncName = NULL;
  const ENCODING *newEncoding = NULL;
  const char *version = NULL;
  const char *versionend;
  const XML_Char *storedversion = NULL;
  int standalone = -1;
  if (!(ns
        ? XmlParseXmlDeclNS
        : XmlParseXmlDecl)(isGeneralTextEntity,
                           encoding,
                           s,
                           next,
                           &eventPtr,
                           &version,
                           &versionend,
                           &encodingName,
                           &newEncoding,
                           &standalone)) {
    if (isGeneralTextEntity)
      return XML_ERROR_TEXT_DECL;
    else
      return XML_ERROR_XML_DECL;
  }
  if (!isGeneralTextEntity && standalone == 1) {
    _dtd->standalone = XML_TRUE;
#ifdef XML_DTD
    if (paramEntityParsing == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
      paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
#endif /* XML_DTD */
  }
  if (xmlDeclHandler) {
    if (encodingName != NULL) {
      storedEncName = poolStoreString(&temp2Pool,
                                      encoding,
                                      encodingName,
                                      encodingName
                                      + XmlNameLength(encoding, encodingName));
      if (!storedEncName)
              return XML_ERROR_NO_MEMORY;
      poolFinish(&temp2Pool);
    }
    if (version) {
      storedversion = poolStoreString(&temp2Pool,
                                      encoding,
                                      version,
                                      versionend - encoding->minBytesPerChar);
      if (!storedversion)
        return XML_ERROR_NO_MEMORY;
    }
    xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);
  }
  else if (defaultHandler)
    reportDefault(parser, encoding, s, next);
  if (protocolEncodingName == NULL) {
    if (newEncoding) {
      if (newEncoding->minBytesPerChar != encoding->minBytesPerChar) {
        eventPtr = encodingName;
        return XML_ERROR_INCORRECT_ENCODING;
      }
      encoding = newEncoding;
    }
    else if (encodingName) {
      enum XML_Error result;
      if (!storedEncName) {
        storedEncName = poolStoreString(
          &temp2Pool, encoding, encodingName,
          encodingName + XmlNameLength(encoding, encodingName));
        if (!storedEncName)
          return XML_ERROR_NO_MEMORY;
      }
      result = handleUnknownEncoding(parser, storedEncName);
      poolClear(&temp2Pool);
      if (result == XML_ERROR_UNKNOWN_ENCODING)
        eventPtr = encodingName;
      return result;
    }
  }
 
  if (storedEncName || storedversion)
    poolClear(&temp2Pool);
 
  return XML_ERROR_NONE;
}

References _dtd, defaultHandler, eventPtr, handlerArg, handleUnknownEncoding(), encoding::minBytesPerChar, ns, geant4_check_module_cycles::parser, poolClear(), poolFinish, poolStoreString(), protocolEncodingName, reportDefault(), s, temp2Pool, XML_ERROR_INCORRECT_ENCODING, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_TEXT_DECL, XML_ERROR_UNKNOWN_ENCODING, XML_ERROR_XML_DECL, XML_PARAM_ENTITY_PARSING_NEVER, XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE, XML_TRUE, xmlDeclHandler, XmlNameLength, XmlParseXmlDecl(), and XmlParseXmlDeclNS.

Referenced by doProlog(), and externalEntityInitProcessor3().

◆ prologInitProcessor()

static enum XML_Error PTRCALL prologInitProcessor	(	XML_Parser	parser,
		const char *	s,
		const char *	end,
		const char **	nextPtr
	)

static

Definition at line 3553 of file xmlparse.cc.

{
  enum XML_Error result = initializeEncoding(parser);
  if (result != XML_ERROR_NONE)
    return result;
  processor = prologProcessor;
  return prologProcessor(parser, s, end, nextPtr);
}

References initializeEncoding(), geant4_check_module_cycles::parser, processor, prologProcessor, s, and XML_ERROR_NONE.

◆ prologProcessor()

static enum XML_Error PTRCALL prologProcessor	(	XML_Parser	parser,
		const char *	s,
		const char *	end,
		const char **	nextPtr
	)

static

Definition at line 3738 of file xmlparse.cc.

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

References doProlog(), geant4_check_module_cycles::parser, ps_finalBuffer, s, and XmlPrologTok.

◆ reportComment()

static int reportComment	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	start,
		const char *	end
	)

static

Definition at line 5312 of file xmlparse.cc.

{
  XML_Char *data;
  if (!commentHandler) {
    if (defaultHandler)
      reportDefault(parser, enc, start, end);
    return 1;
  }
  data = poolStoreString(&tempPool,
                         enc,
                         start + enc->minBytesPerChar * 4,
                         end - enc->minBytesPerChar * 3);
  if (!data)
    return 0;
  normalizeLines(data);
  commentHandler(handlerArg, data);
  poolClear(&tempPool);
  return 1;
}

References commentHandler, defaultHandler, handlerArg, encoding::minBytesPerChar, normalizeLines(), geant4_check_module_cycles::parser, poolClear(), poolStoreString(), reportDefault(), and tempPool.

Referenced by doContent(), doProlog(), and epilogProcessor().

◆ reportDefault()

static void reportDefault	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	start,
		const char *	end
	)

static

Definition at line 5334 of file xmlparse.cc.

{
  if (MUST_CONVERT(enc, s)) {
    const char **eventPP;
    const char **eventEndPP;
    if (enc == encoding) {
      eventPP = &eventPtr;
      eventEndPP = &eventEndPtr;
    }
    else {
      eventPP = &(openInternalEntities->internalEventPtr);
      eventEndPP = &(openInternalEntities->internalEventEndPtr);
    }
    do {
      ICHAR *dataPtr = (ICHAR *)dataBuf;
      XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
      *eventEndPP = s;
      defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
      *eventPP = s;
    } while (s != end);
  }
  else
    defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
}

References dataBuf, dataBufEnd, defaultHandler, eventEndPtr, eventPtr, handlerArg, MUST_CONVERT, openInternalEntities, s, and XmlConvert.

Referenced by doCdataSection(), doContent(), doProlog(), epilogProcessor(), processXmlDecl(), reportComment(), reportProcessingInstruction(), and XML_DefaultCurrent().

◆ reportProcessingInstruction()

static int reportProcessingInstruction	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	start,
		const char *	end
	)

static

Definition at line 5283 of file xmlparse.cc.

{
  const XML_Char *target;
  XML_Char *data;
  const char *tem;
  if (!processingInstructionHandler) {
    if (defaultHandler)
      reportDefault(parser, enc, start, end);
    return 1;
  }
  start += enc->minBytesPerChar * 2;
  tem = start + XmlNameLength(enc, start);
  target = poolStoreString(&tempPool, enc, start, tem);
  if (!target)
    return 0;
  poolFinish(&tempPool);
  data = poolStoreString(&tempPool, enc,
                        XmlSkipS(enc, tem),
                        end - enc->minBytesPerChar*2);
  if (!data)
    return 0;
  normalizeLines(data);
  processingInstructionHandler(handlerArg, target, data);
  poolClear(&tempPool);
  return 1;
}

References defaultHandler, handlerArg, encoding::minBytesPerChar, normalizeLines(), geant4_check_module_cycles::parser, poolClear(), poolFinish, poolStoreString(), processingInstructionHandler, reportDefault(), tempPool, XmlNameLength, and XmlSkipS.

Referenced by doContent(), doProlog(), and epilogProcessor().

◆ setContext()

static XML_Bool setContext	(	XML_Parser	parser,
		const XML_Char *	context
	)

static

Definition at line 5568 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  const XML_Char *s = context;
 
  while (*context != XML_T('\0')) {
    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
      ENTITY *e;
      if (!poolAppendChar(&tempPool, XML_T('\0')))
        return XML_FALSE;
      e = (ENTITY *)lookup(parser, &dtd->generalEntities, poolStart(&tempPool), 0);
      if (e)
        e->open = XML_TRUE;
      if (*s != XML_T('\0'))
        s++;
      context = s;
      poolDiscard(&tempPool);
    }
    else if (*s == XML_T(ASCII_EQUALS)) {
      PREFIX *prefix;
      if (poolLength(&tempPool) == 0)
        prefix = &dtd->defaultPrefix;
      else {
        if (!poolAppendChar(&tempPool, XML_T('\0')))
          return XML_FALSE;
        prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&tempPool),
                                  sizeof(PREFIX));
        if (!prefix)
          return XML_FALSE;
        if (prefix->name == poolStart(&tempPool)) {
          prefix->name = poolCopyString(&dtd->pool, prefix->name);
          if (!prefix->name)
            return XML_FALSE;
        }
        poolDiscard(&tempPool);
      }
      for (context = s + 1;
           *context != CONTEXT_SEP && *context != XML_T('\0');
           context++)
        if (!poolAppendChar(&tempPool, *context))
          return XML_FALSE;
      if (!poolAppendChar(&tempPool, XML_T('\0')))
        return XML_FALSE;
      if (addBinding(parser, prefix, NULL, poolStart(&tempPool),
                     &inheritedBindings) != XML_ERROR_NONE)
        return XML_FALSE;
      poolDiscard(&tempPool);
      if (*context != XML_T('\0'))
        ++context;
      s = context;
    }
    else {
      if (!poolAppendChar(&tempPool, *s))
        return XML_FALSE;
      s++;
    }
  }
  return XML_TRUE;
}

References _dtd, addBinding(), ASCII_EQUALS, g4zmq::context, CONTEXT_SEP, DTD::defaultPrefix, DTD::generalEntities, inheritedBindings, lookup(), prefix::name, ENTITY::open, geant4_check_module_cycles::parser, DTD::pool, poolAppendChar, poolCopyString(), poolDiscard, poolLength, poolStart, DTD::prefixes, s, tempPool, XML_ERROR_NONE, XML_FALSE, XML_T, and XML_TRUE.

Referenced by startParsing(), and XML_ExternalEntityParserCreate().

◆ setElementTypePrefix()

static int setElementTypePrefix	(	XML_Parser	parser,
		ELEMENT_TYPE *	elementType
	)

static

Definition at line 5406 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  const XML_Char *name;
  for (name = elementType->name; *name; name++) {
    if (*name == XML_T(ASCII_COLON)) {
      PREFIX *prefix;
      const XML_Char *s;
      for (s = elementType->name; s != name; s++) {
        if (!poolAppendChar(&dtd->pool, *s))
          return 0;
      }
      if (!poolAppendChar(&dtd->pool, XML_T('\0')))
        return 0;
      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
                                sizeof(PREFIX));
      if (!prefix)
        return 0;
      if (prefix->name == poolStart(&dtd->pool))
        poolFinish(&dtd->pool);
      else
        poolDiscard(&dtd->pool);
      elementType->prefix = prefix;
 
    }
  }
  return 1;
}

References _dtd, ASCII_COLON, lookup(), prefix::name, ELEMENT_TYPE::name, G4InuclParticleNames::name(), geant4_check_module_cycles::parser, DTD::pool, poolAppendChar, poolDiscard, poolFinish, poolStart, ELEMENT_TYPE::prefix, DTD::prefixes, s, and XML_T.

Referenced by getElementType(), and storeAtts().

◆ startParsing()

static XML_Bool startParsing ( XML_Parser parser )

static

Definition at line 708 of file xmlparse.cc.

{
    /* 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;
}

References generate_hash_secret_salt(), hash_secret_salt, implicitContext, ns, geant4_check_module_cycles::parser, setContext(), and XML_TRUE.

Referenced by XML_Parse(), and XML_ParseBuffer().

◆ storeAttributeValue()

static enum XML_Error storeAttributeValue	(	XML_Parser	parser,
		const ENCODING *	enc,
		XML_Bool	isCdata,
		const char *	ptr,
		const char *	end,
		STRING_POOL *	pool
	)

static

Definition at line 4928 of file xmlparse.cc.

{
  enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr,
                                               end, pool);
  if (result)
    return result;
  if (!isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
    poolChop(pool);
  if (!poolAppendChar(pool, XML_T('\0')))
    return XML_ERROR_NO_MEMORY;
  return XML_ERROR_NONE;
}

References appendAttributeValue(), geant4_check_module_cycles::parser, poolAppendChar, poolChop, poolLastChar, poolLength, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, and XML_T.

Referenced by doProlog(), and storeAtts().

◆ storeAtts()

static enum XML_Error storeAtts	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	s,
		TAG_NAME *	tagNamePtr,
		BINDING **	bindingsPtr
	)

static

Definition at line 2704 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  ELEMENT_TYPE *elementType;
  int nDefaultAtts;
  const XML_Char **appAtts;   /* the attribute list for the application */
  int attIndex = 0;
  int prefixLen;
  int i;
  int n;
  XML_Char *uri;
  int nPrefixes = 0;
  BINDING *binding;
  const XML_Char *localPart;
 
  /* lookup the element type name */
  elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str,0);
  if (!elementType) {
    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
    if (!name)
      return XML_ERROR_NO_MEMORY;
    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
                                         sizeof(ELEMENT_TYPE));
    if (!elementType)
      return XML_ERROR_NO_MEMORY;
    if (ns && !setElementTypePrefix(parser, elementType))
      return XML_ERROR_NO_MEMORY;
  }
  nDefaultAtts = elementType->nDefaultAtts;
 
  /* get the attributes from the tokenizer */
  n = XmlGetAttributes(enc, attStr, attsSize, atts);
  if (n + nDefaultAtts > attsSize) {
    int oldAttsSize = attsSize;
    ATTRIBUTE *temp;
#ifdef XML_ATTR_INFO
    XML_AttrInfo *temp2;
#endif
    attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
    temp = (ATTRIBUTE *)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
    if (temp == NULL)
      return XML_ERROR_NO_MEMORY;
    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)
      XmlGetAttributes(enc, attStr, n, atts);
  }
 
  appAtts = (const XML_Char **)atts;
  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 */
    ATTRIBUTE_ID *attId = getAttributeId(parser, enc, currAtt->name,
                                         currAtt->name
                                         + XmlNameLength(enc, currAtt->name));
    if (!attId)
      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
       namespace processing is turned on and different prefixes for the same
       namespace are used. For this case we have a check further down.
    */
    if ((attId->name)[-1]) {
      if (enc == encoding)
        eventPtr = atts[i].name;
      return XML_ERROR_DUPLICATE_ATTRIBUTE;
    }
    (attId->name)[-1] = 1;
    appAtts[attIndex++] = attId->name;
    if (!atts[i].normalized) {
      enum XML_Error result;
      XML_Bool isCdata = XML_TRUE;
 
      /* figure out whether declared as other than CDATA */
      if (attId->maybeTokenized) {
        int j;
        for (j = 0; j < nDefaultAtts; j++) {
          if (attId == elementType->defaultAtts[j].id) {
            isCdata = elementType->defaultAtts[j].isCdata;
            break;
          }
        }
      }
 
      /* normalize the attribute value */
      result = storeAttributeValue(parser, enc, isCdata,
                                   atts[i].valuePtr, atts[i].valueEnd,
                                   &tempPool);
      if (result)
        return result;
      appAtts[attIndex] = poolStart(&tempPool);
      poolFinish(&tempPool);
    }
    else {
      /* the value did not need normalizing */
      appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr,
                                          atts[i].valueEnd);
      if (appAtts[attIndex] == 0)
        return XML_ERROR_NO_MEMORY;
      poolFinish(&tempPool);
    }
    /* handle prefixed attribute names */
    if (attId->prefix) {
      if (attId->xmlns) {
        /* deal with namespace declarations here */
        enum XML_Error result = addBinding(parser, attId->prefix, attId,
                                           appAtts[attIndex], bindingsPtr);
        if (result)
          return result;
        --attIndex;
      }
      else {
        /* deal with other prefixed names later */
        attIndex++;
        nPrefixes++;
        (attId->name)[-1] = 2;
      }
    }
    else
      attIndex++;
  }
 
  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
  nSpecifiedAtts = attIndex;
  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
    for (i = 0; i < attIndex; i += 2)
      if (appAtts[i] == elementType->idAtt->name) {
        idAttIndex = i;
        break;
      }
  }
  else
    idAttIndex = -1;
 
  /* do attribute defaulting */
  for (i = 0; i < nDefaultAtts; i++) {
    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
    if (!(da->id->name)[-1] && da->value) {
      if (da->id->prefix) {
        if (da->id->xmlns) {
          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
                                             da->value, bindingsPtr);
          if (result)
            return result;
        }
        else {
          (da->id->name)[-1] = 2;
          nPrefixes++;
          appAtts[attIndex++] = da->id->name;
          appAtts[attIndex++] = da->value;
        }
      }
      else {
        (da->id->name)[-1] = 1;
        appAtts[attIndex++] = da->id->name;
        appAtts[attIndex++] = da->value;
      }
    }
  }
  appAtts[attIndex] = 0;
 
  /* expand prefixed attribute names, check for duplicates,
     and clear flags that say whether attributes were specified */
  i = 0;
  if (nPrefixes) {
    int j;  /* hash table index */
    unsigned long version = nsAttsVersion;
    int nsAttsSize = (int)1 << nsAttsPower;
    /* size of hash table must be at least 2 * (# of prefixed attributes) */
    if ((nPrefixes << 1) >> nsAttsPower) {  /* true for nsAttsPower = 0 */
      NS_ATT *temp;
      /* hash table size must also be a power of 2 and >= 8 */
      while (nPrefixes >> nsAttsPower++);
      if (nsAttsPower < 3)
        nsAttsPower = 3;
      nsAttsSize = (int)1 << nsAttsPower;
      temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));
      if (!temp)
        return XML_ERROR_NO_MEMORY;
      nsAtts = temp;
      version = 0;  /* force re-initialization of nsAtts hash table */
    }
    /* using a version flag saves us from initializing nsAtts every time */
    if (!version) {  /* initialize version flags when version wraps around */
      version = INIT_ATTS_VERSION;
      for (j = nsAttsSize; j != 0; )
        nsAtts[--j].version = version;
    }
    nsAttsVersion = --version;
 
    /* expand prefixed names and check for duplicates */
    for (; i < attIndex; i += 2) {
      const XML_Char *s = appAtts[i];
      if (s[-1] == 2) {  /* prefixed */
        ATTRIBUTE_ID *id;
        const BINDING *b;
        unsigned long uriHash = hash_secret_salt;
        ((XML_Char *)s)[-1] = 0;  /* clear flag */
        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
        b = id->prefix->binding;
        if (!b)
          return XML_ERROR_UNBOUND_PREFIX;
 
        /* as we expand the name we also calculate its hash value */
        for (j = 0; j < b->uriLen; j++) {
          const XML_Char c = b->uri[j];
          if (!poolAppendChar(&tempPool, c))
            return XML_ERROR_NO_MEMORY;
          uriHash = CHAR_HASH(uriHash, c);
        }
        while (*s++ != XML_T(ASCII_COLON))
          ;
        do {  /* copies null terminator */
          const XML_Char c = *s;
          if (!poolAppendChar(&tempPool, *s))
            return XML_ERROR_NO_MEMORY;
          uriHash = CHAR_HASH(uriHash, c);
        } while (*s++);
 
        { /* Check hash table for duplicate of expanded name (uriName).
             Derived from code in lookup(parser, HASH_TABLE *table, ...).
          */
          unsigned char step = 0;
          unsigned long mask = nsAttsSize - 1;
          j = uriHash & mask;  /* index into hash table */
          while (nsAtts[j].version == version) {
            /* for speed we compare stored hash values first */
            if (uriHash == nsAtts[j].hash) {
              const XML_Char *s1 = poolStart(&tempPool);
              const XML_Char *s2 = nsAtts[j].uriName;
              /* s1 is null terminated, but not s2 */
              for (; *s1 == *s2 && *s1 != 0; s1++, s2++);
              if (*s1 == 0)
                return XML_ERROR_DUPLICATE_ATTRIBUTE;
            }
            if (!step)
              step = PROBE_STEP(uriHash, mask, nsAttsPower);
            j < step ? (j += nsAttsSize - step) : (j -= step);
          }
        }
 
        if (ns_triplets) {  /* append namespace separator and prefix */
          tempPool.ptr[-1] = namespaceSeparator;
          s = b->prefix->name;
          do {
            if (!poolAppendChar(&tempPool, *s))
              return XML_ERROR_NO_MEMORY;
          } while (*s++);
        }
 
        /* store expanded name in attribute list */
        s = poolStart(&tempPool);
        poolFinish(&tempPool);
        appAtts[i] = s;
 
        /* fill empty slot with new version, uriName and hash value */
        nsAtts[j].version = version;
        nsAtts[j].hash = uriHash;
        nsAtts[j].uriName = s;
 
        if (!--nPrefixes) {
          i += 2;
          break;
        }
      }
      else  /* not prefixed */
        ((XML_Char *)s)[-1] = 0;  /* clear flag */
    }
  }
  /* clear flags for the remaining attributes */
  for (; i < attIndex; i += 2)
    ((XML_Char *)(appAtts[i]))[-1] = 0;
  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
    binding->attId->name[-1] = 0;
 
  if (!ns)
    return XML_ERROR_NONE;
 
  /* expand the element type name */
  if (elementType->prefix) {
    binding = elementType->prefix->binding;
    if (!binding)
      return XML_ERROR_UNBOUND_PREFIX;
    localPart = tagNamePtr->str;
    while (*localPart++ != XML_T(ASCII_COLON))
      ;
  }
  else if (dtd->defaultPrefix.binding) {
    binding = dtd->defaultPrefix.binding;
    localPart = tagNamePtr->str;
  }
  else
    return XML_ERROR_NONE;
  prefixLen = 0;
  if (ns_triplets && binding->prefix->name) {
    for (; binding->prefix->name[prefixLen++];)
      ;  /* prefixLen includes null terminator */
  }
  tagNamePtr->localPart = localPart;
  tagNamePtr->uriLen = binding->uriLen;
  tagNamePtr->prefix = binding->prefix->name;
  tagNamePtr->prefixLen = prefixLen;
  for (i = 0; localPart[i++];)
    ;  /* i includes null terminator */
  n = i + binding->uriLen + prefixLen;
  if (n > binding->uriAlloc) {
    TAG *p;
    uri = (XML_Char *)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
    if (!uri)
      return XML_ERROR_NO_MEMORY;
    binding->uriAlloc = n + EXPAND_SPARE;
    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
    for (p = tagStack; p; p = p->parent)
      if (p->name.str == binding->uri)
        p->name.str = uri;
    FREE(binding->uri);
    binding->uri = uri;
  }
  /* if namespaceSeparator != '\0' then uri includes it already */
  uri = binding->uri + binding->uriLen;
  memcpy(uri, localPart, i * sizeof(XML_Char));
  /* we always have a namespace separator between localPart and prefix */
  if (prefixLen) {
    uri += i - 1;
    *uri = namespaceSeparator;  /* replace null terminator */
    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
  }
  tagNamePtr->str = binding->uri;
  return XML_ERROR_NONE;
}

References _dtd, addBinding(), ASCII_COLON, binding::attId, attInfo, DTD::attributeIds, atts, attsSize, prefix::binding, CHAR_HASH, ELEMENT_TYPE::defaultAtts, DTD::defaultPrefix, DTD::elementTypes, eventPtr, EXPAND_SPARE, FREE, getAttributeId(), hash(), hash_secret_salt, DEFAULT_ATTRIBUTE::id, ELEMENT_TYPE::idAtt, idAttIndex, INIT_ATTS_SIZE, INIT_ATTS_VERSION, DEFAULT_ATTRIBUTE::isCdata, TAG_NAME::localPart, lookup(), MALLOC, attribute_id::maybeTokenized, CLHEP::detail::n, prefix::name, tag::name, attribute_id::name, ATTRIBUTE::name, G4InuclParticleNames::name(), namespaceSeparator, ELEMENT_TYPE::nDefaultAtts, binding::nextTagBinding, ns, ns_triplets, nsAtts, nsAttsPower, nsAttsVersion, nSpecifiedAtts, tag::parent, parseEndByteIndex, parseEndPtr, geant4_check_module_cycles::parser, DTD::pool, poolAppendChar, poolCopyString(), poolFinish, poolStart, poolStoreString(), binding::prefix, TAG_NAME::prefix, attribute_id::prefix, ELEMENT_TYPE::prefix, TAG_NAME::prefixLen, PROBE_STEP, REALLOC, s, setElementTypePrefix(), storeAttributeValue(), TAG_NAME::str, tagStack, tempPool, binding::uri, binding::uriAlloc, binding::uriLen, TAG_NAME::uriLen, DEFAULT_ATTRIBUTE::value, ATTRIBUTE::valueEnd, ATTRIBUTE::valuePtr, XML_ERROR_DUPLICATE_ATTRIBUTE, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_UNBOUND_PREFIX, XML_T, XML_TRUE, XmlGetAttributes, XmlNameLength, and attribute_id::xmlns.

Referenced by doContent().

◆ storeEntityValue()

static enum XML_Error storeEntityValue	(	XML_Parser	parser,
		const ENCODING *	enc,
		const char *	start,
		const char *	end
	)

static

Definition at line 5094 of file xmlparse.cc.

{
  DTD * const dtd = _dtd;  /* save one level of indirection */
  STRING_POOL *pool = &(dtd->entityValuePool);
  enum XML_Error result = XML_ERROR_NONE;
#ifdef XML_DTD
  int oldInEntityValue = prologState.inEntityValue;
  prologState.inEntityValue = 1;
#endif /* XML_DTD */
  /* never return Null for the value argument in EntityDeclHandler,
     since this would indicate an external entity; therefore we
     have to make sure that entityValuePool.start is not null */
  if (!pool->blocks) {
    if (!poolGrow(pool))
      return XML_ERROR_NO_MEMORY;
  }
 
  for (;;) {
    const char *next;
    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
    switch (tok) {
    case XML_TOK_PARAM_ENTITY_REF:
#ifdef XML_DTD
      if (isParamEntity || enc != encoding) {
        const XML_Char *name;
        ENTITY *entity;
        name = poolStoreString(&tempPool, enc,
                               entityTextPtr + enc->minBytesPerChar,
                               next - enc->minBytesPerChar);
        if (!name) {
          result = XML_ERROR_NO_MEMORY;
          goto endEntityValue;
        }
        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
        poolDiscard(&tempPool);
        if (!entity) {
          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
          /* cannot report skipped entity here - see comments on
             skippedEntityHandler
          if (skippedEntityHandler)
            skippedEntityHandler(handlerArg, name, 0);
          */
          dtd->keepProcessing = dtd->standalone;
          goto endEntityValue;
        }
        if (entity->open) {
          if (enc == encoding)
            eventPtr = entityTextPtr;
          result = XML_ERROR_RECURSIVE_ENTITY_REF;
          goto endEntityValue;
        }
        if (entity->systemId) {
          if (externalEntityRefHandler) {
            dtd->paramEntityRead = XML_FALSE;
            entity->open = XML_TRUE;
            if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                          0,
                                          entity->base,
                                          entity->systemId,
                                          entity->publicId)) {
              entity->open = XML_FALSE;
              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
              goto endEntityValue;
            }
            entity->open = XML_FALSE;
            if (!dtd->paramEntityRead)
              dtd->keepProcessing = dtd->standalone;
          }
          else
            dtd->keepProcessing = dtd->standalone;
        }
        else {
          entity->open = XML_TRUE;
          result = storeEntityValue(parser,
                                    internalEncoding,
                                    (char *)entity->textPtr,
                                    (char *)(entity->textPtr
                                             + entity->textLen));
          entity->open = XML_FALSE;
          if (result)
            goto endEntityValue;
        }
        break;
      }
#endif /* XML_DTD */
      /* In the internal subset, PE references are not legal
         within markup declarations, e.g entity values in this case. */
      eventPtr = entityTextPtr;
      result = XML_ERROR_PARAM_ENTITY_REF;
      goto endEntityValue;
    case XML_TOK_NONE:
      result = XML_ERROR_NONE;
      goto endEntityValue;
    case XML_TOK_ENTITY_REF:
    case XML_TOK_DATA_CHARS:
      if (!poolAppend(pool, enc, entityTextPtr, next)) {
        result = XML_ERROR_NO_MEMORY;
        goto endEntityValue;
      }
      break;
    case XML_TOK_TRAILING_CR:
      next = entityTextPtr + enc->minBytesPerChar;
      /* fall through */
    case XML_TOK_DATA_NEWLINE:
      if (pool->end == pool->ptr && !poolGrow(pool)) {
              result = XML_ERROR_NO_MEMORY;
        goto endEntityValue;
      }
      *(pool->ptr)++ = 0xA;
      break;
    case XML_TOK_CHAR_REF:
      {
        XML_Char buf[XML_ENCODE_MAX];
        int i;
        int n = XmlCharRefNumber(enc, entityTextPtr);
        if (n < 0) {
          if (enc == encoding)
            eventPtr = entityTextPtr;
          result = XML_ERROR_BAD_CHAR_REF;
          goto endEntityValue;
        }
        n = XmlEncode(n, (ICHAR *)buf);
        if (!n) {
          if (enc == encoding)
            eventPtr = entityTextPtr;
          result = XML_ERROR_BAD_CHAR_REF;
          goto endEntityValue;
        }
        for (i = 0; i < n; i++) {
          if (pool->end == pool->ptr && !poolGrow(pool)) {
            result = XML_ERROR_NO_MEMORY;
            goto endEntityValue;
          }
          *(pool->ptr)++ = buf[i];
        }
      }
      break;
    case XML_TOK_PARTIAL:
      if (enc == encoding)
        eventPtr = entityTextPtr;
      result = XML_ERROR_INVALID_TOKEN;
      goto endEntityValue;
    case XML_TOK_INVALID:
      if (enc == encoding)
        eventPtr = next;
      result = XML_ERROR_INVALID_TOKEN;
      goto endEntityValue;
    default:
      if (enc == encoding)
        eventPtr = entityTextPtr;
      result = XML_ERROR_UNEXPECTED_STATE;
      goto endEntityValue;
    }
    entityTextPtr = next;
  }
endEntityValue:
#ifdef XML_DTD
  prologState.inEntityValue = oldInEntityValue;
#endif /* XML_DTD */
  return result;
}

References _dtd, ENTITY::base, STRING_POOL::blocks, STRING_POOL::end, DTD::entityValuePool, eventPtr, externalEntityRefHandler, externalEntityRefHandlerArg, internalEncoding, DTD::keepProcessing, lookup(), encoding::minBytesPerChar, CLHEP::detail::n, G4InuclParticleNames::name(), ENTITY::open, geant4_check_module_cycles::parser, poolAppend(), poolDiscard, poolGrow(), poolStoreString(), prologState, STRING_POOL::ptr, ENTITY::publicId, DTD::standalone, storeEntityValue(), ENTITY::systemId, tempPool, ENTITY::textLen, ENTITY::textPtr, XML_ENCODE_MAX, XML_ERROR_BAD_CHAR_REF, XML_ERROR_EXTERNAL_ENTITY_HANDLING, XML_ERROR_INVALID_TOKEN, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_PARAM_ENTITY_REF, XML_ERROR_RECURSIVE_ENTITY_REF, XML_ERROR_UNEXPECTED_STATE, XML_FALSE, XML_TOK_CHAR_REF, XML_TOK_DATA_CHARS, XML_TOK_DATA_NEWLINE, XML_TOK_ENTITY_REF, XML_TOK_INVALID, XML_TOK_NONE, XML_TOK_PARAM_ENTITY_REF, XML_TOK_PARTIAL, XML_TOK_TRAILING_CR, XML_TRUE, XmlCharRefNumber, XmlEncode, and XmlEntityValueTok.

Referenced by doProlog(), and storeEntityValue().

◆ storeRawNames()

static XML_Bool storeRawNames ( XML_Parser parser )

static

Definition at line 2061 of file xmlparse.cc.

{
  TAG *tag = tagStack;
  while (tag) {
    int bufSize;
    int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
    char *rawNameBuf = tag->buf + nameLen;
    /* Stop if already stored.  Since tagStack is a stack, we can stop
       at the first entry that has already been copied; everything
       below it in the stack is already been accounted for in a
       previous call to this function.
    */
    if (tag->rawName == rawNameBuf)
      break;
    /* For re-use purposes we need to ensure that the
       size of tag->buf is a multiple of sizeof(XML_Char).
    */
    bufSize = nameLen + ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
    if (bufSize > tag->bufEnd - tag->buf) {
      char *temp = (char *)REALLOC(tag->buf, bufSize);
      if (temp == NULL)
        return XML_FALSE;
      /* if tag->name.str points to tag->buf (only when namespace
         processing is off) then we have to update it
      */
      if (tag->name.str == (XML_Char *)tag->buf)
        tag->name.str = (XML_Char *)temp;
      /* if tag->name.localPart is set (when namespace processing is on)
         then update it as well, since it will always point into tag->buf
      */
      if (tag->name.localPart)
        tag->name.localPart = (XML_Char *)temp + (tag->name.localPart -
                                                  (XML_Char *)tag->buf);
      tag->buf = temp;
      tag->bufEnd = temp + bufSize;
      rawNameBuf = temp + nameLen;
    }
    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
    tag->rawName = rawNameBuf;
    tag = tag->parent;
  }
  return XML_TRUE;
}

References tag::buf, tag::bufEnd, TAG_NAME::localPart, tag::name, tag::parent, tag::rawName, tag::rawNameLength, REALLOC, ROUND_UP, TAG_NAME::str, TAG_NAME::strLen, tagStack, XML_FALSE, and XML_TRUE.

Referenced by contentProcessor(), and externalEntityContentProcessor().

◆ XML_DefaultCurrent()

void XMLCALL XML_DefaultCurrent ( XML_Parser parser )

Definition at line 1920 of file xmlparse.cc.

{
  if (defaultHandler) {
    if (openInternalEntities)
      reportDefault(parser,
                    internalEncoding,
                    openInternalEntities->internalEventPtr,
                    openInternalEntities->internalEventEndPtr);
    else
      reportDefault(parser, encoding, eventPtr, eventEndPtr);
  }
}

References defaultHandler, eventEndPtr, eventPtr, internalEncoding, openInternalEntities, geant4_check_module_cycles::parser, and reportDefault().

◆ XML_ErrorString()

const XML_LChar *XMLCALL XML_ErrorString ( enum XML_Error code )

Definition at line 1934 of file xmlparse.cc.

{
  static const XML_LChar* const message[] = {
    0,
    XML_L("out of memory"),
    XML_L("syntax error"),
    XML_L("no element found"),
    XML_L("not well-formed (invalid token)"),
    XML_L("unclosed token"),
    XML_L("partial character"),
    XML_L("mismatched tag"),
    XML_L("duplicate attribute"),
    XML_L("junk after document element"),
    XML_L("illegal parameter entity reference"),
    XML_L("undefined entity"),
    XML_L("recursive entity reference"),
    XML_L("asynchronous entity"),
    XML_L("reference to invalid character number"),
    XML_L("reference to binary entity"),
    XML_L("reference to external entity in attribute"),
    XML_L("XML or text declaration not at start of entity"),
    XML_L("unknown encoding"),
    XML_L("encoding specified in XML declaration is incorrect"),
    XML_L("unclosed CDATA section"),
    XML_L("error in processing external entity reference"),
    XML_L("document is not standalone"),
    XML_L("unexpected parser state - please send a bug report"),
    XML_L("entity declared in parameter entity"),
    XML_L("requested feature requires XML_DTD support in Expat"),
    XML_L("cannot change setting once parsing has begun"),
    XML_L("unbound prefix"),
    XML_L("must not undeclare prefix"),
    XML_L("incomplete markup in parameter entity"),
    XML_L("XML declaration not well-formed"),
    XML_L("text declaration not well-formed"),
    XML_L("illegal character(s) in public id"),
    XML_L("parser suspended"),
    XML_L("parser not suspended"),
    XML_L("parsing aborted"),
    XML_L("parsing finished"),
    XML_L("cannot suspend in external parameter entity"),
    XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),
    XML_L("reserved prefix (xmlns) must not be declared or undeclared"),
    XML_L("prefix must not be bound to one of the reserved namespace names")
  };
  if (code > 0 && code < sizeof(message)/sizeof(message[0]))
    return message[code];
  return NULL;
}

References XML_L.

Referenced by xDataXML_endXMLParsing().

◆ XML_ExpatVersion()

const XML_LChar *XMLCALL XML_ExpatVersion ( void )

Definition at line 1985 of file xmlparse.cc.

                       {
 
  /* V1 is used to string-ize the version number. However, it would
     string-ize the actual version macro *names* unless we get them
     substituted before being passed to V1. CPP is defined to expand
     a macro, then rescan for more expansions. Thus, we use V2 to expand
     the version macros, then CPP will expand the resulting V1() macro
     with the correct numerals. */
  /* ### I'm assuming cpp is portable in this respect... */
 
#define V1(a,b,c) XML_L(#a)XML_L(".")XML_L(#b)XML_L(".")XML_L(#c)
#define V2(a,b,c) XML_L("expat_")V1(a,b,c)
 
  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
 
#undef V1
#undef V2
}

References V2, XML_MAJOR_VERSION, XML_MICRO_VERSION, and XML_MINOR_VERSION.

◆ XML_ExpatVersionInfo()

XML_Expat_Version XMLCALL XML_ExpatVersionInfo ( void )

Definition at line 2005 of file xmlparse.cc.

{
  XML_Expat_Version version;
 
  version.major = XML_MAJOR_VERSION;
  version.minor = XML_MINOR_VERSION;
  version.micro = XML_MICRO_VERSION;
 
  return version;
}

References XML_Expat_Version::major, XML_Expat_Version::micro, XML_Expat_Version::minor, XML_MAJOR_VERSION, XML_MICRO_VERSION, and XML_MINOR_VERSION.

◆ XML_ExternalEntityParserCreate()

XML_Parser XMLCALL XML_ExternalEntityParserCreate	(	XML_Parser	oldParser,
		const XML_Char *	context,
		const XML_Char *	encodingName
	)

Definition at line 986 of file xmlparse.cc.

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

References _dtd, attlistDeclHandler, characterDataHandler, commentHandler, g4zmq::context, declElementType, defaultExpandInternalEntities, defaultHandler, dtdCopy(), elementDeclHandler, endCdataSectionHandler, endElementHandler, endNamespaceDeclHandler, entityDeclHandler, externalEntityInitProcessor, externalEntityRefHandler, externalEntityRefHandlerArg, handlerArg, hash_secret_salt, namespaceSeparator, notationDeclHandler, notStandaloneHandler, ns, ns_triplets, parentParser, geant4_check_module_cycles::parser, parserCreate(), processingInstructionHandler, processor, prologState, setContext(), skippedEntityHandler, startCdataSectionHandler, startElementHandler, startNamespaceDeclHandler, unknownEncodingHandler, unparsedEntityDeclHandler, userData, XML_ParserFree(), XML_TRUE, and xmlDeclHandler.

◆ XML_FreeContentModel()

void XMLCALL XML_FreeContentModel	(	XML_Parser	parser,
		XML_Content *	model
	)

Definition at line 1896 of file xmlparse.cc.

{
  FREE(model);
}

References FREE.

◆ XML_GetBase()

const XML_Char *XMLCALL XML_GetBase ( XML_Parser parser )

Definition at line 1253 of file xmlparse.cc.

{
  return curBase;
}

References curBase.

◆ XML_GetBuffer()

void *XMLCALL XML_GetBuffer	(	XML_Parser	parser,
		int	len
	)

Definition at line 1685 of file xmlparse.cc.

{
  switch (ps_parsing) {
  case XML_SUSPENDED:
    errorCode = XML_ERROR_SUSPENDED;
    return NULL;
  case XML_FINISHED:
    errorCode = XML_ERROR_FINISHED;
    return NULL;
  default: ;
  }
 
  if (len > bufferLim - bufferEnd) {
    /* FIXME avoid integer overflow */
    int neededSize = len + (int)(bufferEnd - bufferPtr);
#ifdef XML_CONTEXT_BYTES
    int keep = (int)(bufferPtr - buffer);
 
    if (keep > XML_CONTEXT_BYTES)
      keep = XML_CONTEXT_BYTES;
    neededSize += keep;
#endif  /* defined XML_CONTEXT_BYTES */
    if (neededSize  <= bufferLim - buffer) {
#ifdef XML_CONTEXT_BYTES
      if (keep < bufferPtr - buffer) {
        int offset = (int)(bufferPtr - buffer) - keep;
        memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
        bufferEnd -= offset;
        bufferPtr -= offset;
      }
#else
      memmove(buffer, bufferPtr, bufferEnd - bufferPtr);
      bufferEnd = buffer + (bufferEnd - bufferPtr);
      bufferPtr = buffer;
#endif  /* not defined XML_CONTEXT_BYTES */
    }
    else {
      char *newBuf;
      int bufferSize = (int)(bufferLim - bufferPtr);
      if (bufferSize == 0)
        bufferSize = INIT_BUFFER_SIZE;
      do {
        bufferSize *= 2;
      } while (bufferSize < neededSize);
      newBuf = (char *)MALLOC(bufferSize);
      if (newBuf == 0) {
        errorCode = XML_ERROR_NO_MEMORY;
        return NULL;
      }
      bufferLim = newBuf + bufferSize;
#ifdef XML_CONTEXT_BYTES
      if (bufferPtr) {
        int keep = (int)(bufferPtr - buffer);
        if (keep > XML_CONTEXT_BYTES)
          keep = XML_CONTEXT_BYTES;
        memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
        FREE(buffer);
        buffer = newBuf;
        bufferEnd = buffer + (bufferEnd - bufferPtr) + keep;
        bufferPtr = buffer + keep;
      }
      else {
        bufferEnd = newBuf + (bufferEnd - bufferPtr);
        bufferPtr = buffer = newBuf;
      }
#else
      if (bufferPtr) {
        memcpy(newBuf, bufferPtr, bufferEnd - bufferPtr);
        FREE(buffer);
      }
      bufferEnd = newBuf + (bufferEnd - bufferPtr);
      bufferPtr = buffer = newBuf;
#endif  /* not defined XML_CONTEXT_BYTES */
    }
    eventPtr = eventEndPtr = NULL;
    positionPtr = NULL;
  }
  return bufferEnd;
}

References buffer, bufferEnd, bufferLim, bufferPtr, errorCode, eventEndPtr, eventPtr, FREE, INIT_BUFFER_SIZE, MALLOC, positionPtr, ps_parsing, XML_CONTEXT_BYTES, XML_ERROR_FINISHED, XML_ERROR_NO_MEMORY, XML_ERROR_SUSPENDED, XML_FINISHED, and XML_SUSPENDED.

Referenced by XML_Parse().

◆ XML_GetCurrentByteCount()

int XMLCALL XML_GetCurrentByteCount ( XML_Parser parser )

Definition at line 1855 of file xmlparse.cc.

{
  if (eventEndPtr && eventPtr)
    return (int)(eventEndPtr - eventPtr);
  return 0;
}

References eventEndPtr, and eventPtr.

◆ XML_GetCurrentByteIndex()

XML_Index XMLCALL XML_GetCurrentByteIndex ( XML_Parser parser )

Definition at line 1847 of file xmlparse.cc.

{
  if (eventPtr)
    return parseEndByteIndex - (parseEndPtr - eventPtr);
  return -1;
}

References eventPtr, parseEndByteIndex, and parseEndPtr.

◆ XML_GetCurrentColumnNumber()

XML_Size XMLCALL XML_GetCurrentColumnNumber ( XML_Parser parser )

Definition at line 1886 of file xmlparse.cc.

{
  if (eventPtr && eventPtr >= positionPtr) {
    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
    positionPtr = eventPtr;
  }
  return position.columnNumber;
}

References position::columnNumber, eventPtr, positionPtr, and XmlUpdatePosition.

Referenced by xDataXML_endXMLParsing(), and xDataXML_parseGetCurrentPosition().

◆ XML_GetCurrentLineNumber()

XML_Size XMLCALL XML_GetCurrentLineNumber ( XML_Parser parser )

Definition at line 1876 of file xmlparse.cc.

{
  if (eventPtr && eventPtr >= positionPtr) {
    XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);
    positionPtr = eventPtr;
  }
  return position.lineNumber + 1;
}

References eventPtr, position::lineNumber, positionPtr, and XmlUpdatePosition.

Referenced by xDataXML_endXMLParsing(), and xDataXML_parseGetCurrentPosition().

◆ XML_GetErrorCode()

enum XML_Error XMLCALL XML_GetErrorCode ( XML_Parser parser )

Definition at line 1841 of file xmlparse.cc.

{
  return errorCode;
}

References errorCode.

Referenced by xDataXML_endXMLParsing().

◆ XML_GetFeatureList()

const XML_Feature *XMLCALL XML_GetFeatureList ( void )

Definition at line 2017 of file xmlparse.cc.

{
  static const XML_Feature features[] = {
    {XML_FEATURE_SIZEOF_XML_CHAR,  XML_L("sizeof(XML_Char)"),
     sizeof(XML_Char)},
    {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
     sizeof(XML_LChar)},
#ifdef XML_UNICODE
    {XML_FEATURE_UNICODE,          XML_L("XML_UNICODE"), 0},
#endif
#ifdef XML_UNICODE_WCHAR_T
    {XML_FEATURE_UNICODE_WCHAR_T,  XML_L("XML_UNICODE_WCHAR_T"), 0},
#endif
#ifdef XML_DTD
    {XML_FEATURE_DTD,              XML_L("XML_DTD"), 0},
#endif
#ifdef XML_CONTEXT_BYTES
    {XML_FEATURE_CONTEXT_BYTES,    XML_L("XML_CONTEXT_BYTES"),
     XML_CONTEXT_BYTES},
#endif
#ifdef XML_MIN_SIZE
    {XML_FEATURE_MIN_SIZE,         XML_L("XML_MIN_SIZE"), 0},
#endif
#ifdef XML_NS
    {XML_FEATURE_NS,               XML_L("XML_NS"), 0},
#endif
#ifdef XML_LARGE_SIZE
    {XML_FEATURE_LARGE_SIZE,       XML_L("XML_LARGE_SIZE"), 0},
#endif
#ifdef XML_ATTR_INFO
    {XML_FEATURE_ATTR_INFO,        XML_L("XML_ATTR_INFO"), 0},
#endif
    {XML_FEATURE_END,              NULL, 0}
  };
 
  return features;
}

References XML_CONTEXT_BYTES, XML_FEATURE_ATTR_INFO, XML_FEATURE_CONTEXT_BYTES, XML_FEATURE_DTD, XML_FEATURE_END, XML_FEATURE_LARGE_SIZE, XML_FEATURE_MIN_SIZE, XML_FEATURE_NS, XML_FEATURE_SIZEOF_XML_CHAR, XML_FEATURE_SIZEOF_XML_LCHAR, XML_FEATURE_UNICODE, XML_FEATURE_UNICODE_WCHAR_T, and XML_L.

◆ XML_GetIdAttributeIndex()

int XMLCALL XML_GetIdAttributeIndex ( XML_Parser parser )

Definition at line 1265 of file xmlparse.cc.

{
  return idAttIndex;
}

References idAttIndex.

◆ XML_GetInputContext()

const char *XMLCALL XML_GetInputContext	(	XML_Parser	parser,
		int *	offset,
		int *	size
	)

Definition at line 1863 of file xmlparse.cc.

{
#ifdef XML_CONTEXT_BYTES
  if (eventPtr && buffer) {
    *offset = (int)(eventPtr - buffer);
    *size   = (int)(bufferEnd - buffer);
    return buffer;
  }
#endif /* defined XML_CONTEXT_BYTES */
  return (char *) 0;
}

References buffer, bufferEnd, and eventPtr.

◆ XML_GetParsingStatus()

void XMLCALL XML_GetParsingStatus	(	XML_Parser	parser,
		XML_ParsingStatus *	status
	)

Definition at line 1834 of file xmlparse.cc.

{
  assert(status != NULL);
  *status = parser->m_parsingStatus;
}

References geant4_check_module_cycles::parser.

◆ XML_GetSpecifiedAttributeCount()

int XMLCALL XML_GetSpecifiedAttributeCount ( XML_Parser parser )

Definition at line 1259 of file xmlparse.cc.

{
  return nSpecifiedAtts;
}

References nSpecifiedAtts.

◆ XML_MemFree()

void XMLCALL XML_MemFree	(	XML_Parser	parser,
		void *	ptr
	)

Definition at line 1914 of file xmlparse.cc.

{
  FREE(ptr);
}

References FREE.

◆ XML_MemMalloc()

void *XMLCALL XML_MemMalloc	(	XML_Parser	parser,
		size_t	size
	)

Definition at line 1902 of file xmlparse.cc.

{
  return MALLOC(size);
}

References MALLOC.

◆ XML_MemRealloc()

void *XMLCALL XML_MemRealloc	(	XML_Parser	parser,
		void *	ptr,
		size_t	size
	)

Definition at line 1908 of file xmlparse.cc.

{
  return REALLOC(ptr, size);
}

References REALLOC.

◆ XML_Parse()

enum XML_Status XMLCALL XML_Parse	(	XML_Parser	parser,
		const char *	s,
		int	len,
		int	isFinal
	)

Definition at line 1506 of file xmlparse.cc.

{
  switch (ps_parsing) {
  case XML_SUSPENDED:
    errorCode = XML_ERROR_SUSPENDED;
    return XML_STATUS_ERROR;
  case XML_FINISHED:
    errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  case XML_INITIALIZED:
    if (parentParser == NULL && !startParsing(parser)) {
      errorCode = XML_ERROR_NO_MEMORY;
      return XML_STATUS_ERROR;
    }
  default:
    ps_parsing = XML_PARSING;
  }
 
  if (len == 0) {
    ps_finalBuffer = (XML_Bool)isFinal;
    if (!isFinal)
      return XML_STATUS_OK;
    positionPtr = bufferPtr;
    parseEndPtr = bufferEnd;
 
    /* If data are left over from last buffer, and we now know that these
       data are the final chunk of input, then we have to check them again
       to detect errors based on that fact.
    */
    errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
 
    if (errorCode == XML_ERROR_NONE) {
      switch (ps_parsing) {
      case XML_SUSPENDED:
        XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
        positionPtr = bufferPtr;
        return XML_STATUS_SUSPENDED;
      case XML_INITIALIZED:
      case XML_PARSING:
        ps_parsing = XML_FINISHED;
        /* fall through */
      default:
        return XML_STATUS_OK;
      }
    }
    eventEndPtr = eventPtr;
    processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
#ifndef XML_CONTEXT_BYTES
  else if (bufferPtr == bufferEnd) {
    const char *end;
    int nLeftOver;
    enum XML_Error result;
    parseEndByteIndex += len;
    positionPtr = s;
    ps_finalBuffer = (XML_Bool)isFinal;
 
    errorCode = processor(parser, s, parseEndPtr = s + len, &end);
 
    if (errorCode != XML_ERROR_NONE) {
      eventEndPtr = eventPtr;
      processor = errorProcessor;
      return XML_STATUS_ERROR;
    }
    else {
      switch (ps_parsing) {
      case XML_SUSPENDED:
        result = XML_STATUS_SUSPENDED;
        break;
      case XML_INITIALIZED:
      case XML_PARSING:
        if (isFinal) {
          ps_parsing = XML_FINISHED;
          return XML_STATUS_OK;
        }
      /* fall through */
      default:
        result = XML_STATUS_OK;
      }
    }
 
    XmlUpdatePosition(encoding, positionPtr, end, &position);
    nLeftOver = s + len - end;
    if (nLeftOver) {
      if (buffer == NULL || nLeftOver > bufferLim - buffer) {
        /* FIXME avoid integer overflow */
        char *temp;
        temp = (buffer == NULL
                ? (char *)MALLOC(len * 2)
                : (char *)REALLOC(buffer, len * 2));
        if (temp == NULL) {
          errorCode = XML_ERROR_NO_MEMORY;
          eventPtr = eventEndPtr = NULL;
          processor = errorProcessor;
          return XML_STATUS_ERROR;
        }
        buffer = temp;
        bufferLim = buffer + len * 2;
      }
      memcpy(buffer, end, nLeftOver);
    }
    bufferPtr = buffer;
    bufferEnd = buffer + nLeftOver;
    positionPtr = bufferPtr;
    parseEndPtr = bufferEnd;
    eventPtr = bufferPtr;
    eventEndPtr = bufferPtr;
    return result;
  }
#endif  /* not defined XML_CONTEXT_BYTES */
  else {
    void *buff = XML_GetBuffer(parser, len);
    if (buff == NULL)
      return XML_STATUS_ERROR;
    else {
      memcpy(buff, s, len);
      return XML_ParseBuffer(parser, len, isFinal);
    }
  }
}

References buffer, bufferEnd, bufferLim, bufferPtr, errorCode, errorProcessor, eventEndPtr, eventPtr, MALLOC, parentParser, parseEndByteIndex, parseEndPtr, geant4_check_module_cycles::parser, positionPtr, processor, ps_finalBuffer, ps_parsing, REALLOC, s, startParsing(), XML_ERROR_FINISHED, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_SUSPENDED, XML_FINISHED, XML_GetBuffer(), XML_INITIALIZED, XML_ParseBuffer(), XML_PARSING, XML_STATUS_ERROR, XML_STATUS_OK, XML_STATUS_SUSPENDED, XML_SUSPENDED, and XmlUpdatePosition.

Referenced by xDataXML_endXMLParsing(), and xDataXML_parse().

◆ XML_ParseBuffer()

enum XML_Status XMLCALL XML_ParseBuffer	(	XML_Parser	parser,
		int	len,
		int	isFinal
	)

Definition at line 1629 of file xmlparse.cc.

{
  const char *start;
  enum XML_Status result = XML_STATUS_OK;
 
  switch (ps_parsing) {
  case XML_SUSPENDED:
    errorCode = XML_ERROR_SUSPENDED;
    return XML_STATUS_ERROR;
  case XML_FINISHED:
    errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  case XML_INITIALIZED:
    if (parentParser == NULL && !startParsing(parser)) {
      errorCode = XML_ERROR_NO_MEMORY;
      return XML_STATUS_ERROR;
    }
  default:
    ps_parsing = XML_PARSING;
  }
 
  start = bufferPtr;
  positionPtr = start;
  bufferEnd += len;
  parseEndPtr = bufferEnd;
  parseEndByteIndex += len;
  ps_finalBuffer = (XML_Bool)isFinal;
 
  errorCode = processor(parser, start, parseEndPtr, &bufferPtr);
 
  if (errorCode != XML_ERROR_NONE) {
    eventEndPtr = eventPtr;
    processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
  else {
    switch (ps_parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED:
    case XML_PARSING:
      if (isFinal) {
        ps_parsing = XML_FINISHED;
        return result;
      }
    default: ;  /* should not happen */
    }
  }
 
  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  positionPtr = bufferPtr;
  return result;
}

References bufferEnd, bufferPtr, errorCode, errorProcessor, eventEndPtr, eventPtr, parentParser, parseEndByteIndex, parseEndPtr, geant4_check_module_cycles::parser, positionPtr, processor, ps_finalBuffer, ps_parsing, startParsing(), XML_ERROR_FINISHED, XML_ERROR_NO_MEMORY, XML_ERROR_NONE, XML_ERROR_SUSPENDED, XML_FINISHED, XML_INITIALIZED, XML_PARSING, XML_STATUS_ERROR, XML_STATUS_OK, XML_STATUS_SUSPENDED, XML_SUSPENDED, and XmlUpdatePosition.

Referenced by XML_Parse().

◆ XML_ParserCreate()

XML_Parser XMLCALL XML_ParserCreate ( const XML_Char * encodingName )

Definition at line 677 of file xmlparse.cc.

{
  return XML_ParserCreate_MM(encodingName, NULL, NULL);
}

References XML_ParserCreate_MM().

Referenced by xDataXML_initializeDoc().

◆ XML_ParserCreate_MM()

XML_Parser XMLCALL XML_ParserCreate_MM	(	const XML_Char *	encodingName,
		const XML_Memory_Handling_Suite *	memsuite,
		const XML_Char *	nameSep
	)

Definition at line 723 of file xmlparse.cc.

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

References parserCreate().

Referenced by XML_ParserCreate(), and XML_ParserCreateNS().

◆ XML_ParserCreateNS()

XML_Parser XMLCALL XML_ParserCreateNS	(	const XML_Char *	encodingName,
		XML_Char	nsSep
	)

Definition at line 683 of file xmlparse.cc.

{
  XML_Char tmp[2];
  *tmp = nsSep;
  return XML_ParserCreate_MM(encodingName, NULL, tmp);
}

References XML_ParserCreate_MM().

◆ XML_ParserFree()

void XMLCALL XML_ParserFree ( XML_Parser parser )

Definition at line 1136 of file xmlparse.cc.

{
  TAG *tagList;
  OPEN_INTERNAL_ENTITY *entityList;
  if (parser == NULL)
    return;
  /* free tagStack and freeTagList */
  tagList = tagStack;
  for (;;) {
    TAG *p;
    if (tagList == NULL) {
      if (freeTagList == NULL)
        break;
      tagList = freeTagList;
      freeTagList = NULL;
    }
    p = tagList;
    tagList = tagList->parent;
    FREE(p->buf);
    destroyBindings(p->bindings, parser);
    FREE(p);
  }
  /* free openInternalEntities and freeInternalEntities */
  entityList = openInternalEntities;
  for (;;) {
    OPEN_INTERNAL_ENTITY *openEntity;
    if (entityList == NULL) {
      if (freeInternalEntities == NULL)
        break;
      entityList = freeInternalEntities;
      freeInternalEntities = NULL;
    }
    openEntity = entityList;
    entityList = entityList->next;
    FREE(openEntity);
  }
 
  destroyBindings(freeBindingList, parser);
  destroyBindings(inheritedBindings, parser);
  poolDestroy(&tempPool);
  poolDestroy(&temp2Pool);
#ifdef XML_DTD
  /* external parameter entity parsers share the DTD structure
     parser->m_dtd with the root parser, so we must not destroy it
  */
  if (!isParamEntity && _dtd)
#else
  if (_dtd)
#endif /* XML_DTD */
    dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);
  FREE((void *)atts);
#ifdef XML_ATTR_INFO
  FREE((void *)attInfo);
#endif
  FREE(groupConnector);
  FREE(buffer);
  FREE(dataBuf);
  FREE(nsAtts);
  FREE(unknownEncodingMem);
  if (unknownEncodingRelease)
    unknownEncodingRelease(unknownEncodingData);
  FREE(parser);
}

References _dtd, attInfo, atts, tag::bindings, tag::buf, buffer, dataBuf, destroyBindings(), dtdDestroy(), FREE, freeBindingList, freeInternalEntities, freeTagList, groupConnector, inheritedBindings, open_internal_entity::next, nsAtts, openInternalEntities, tag::parent, parentParser, geant4_check_module_cycles::parser, poolDestroy(), tagStack, temp2Pool, tempPool, unknownEncodingData, unknownEncodingMem, and unknownEncodingRelease.

Referenced by parserCreate(), xDataXML_endXMLParsing(), and XML_ExternalEntityParserCreate().

◆ XML_ParserReset()

XML_Bool XMLCALL XML_ParserReset	(	XML_Parser	parser,
		const XML_Char *	encodingName
	)

Definition at line 931 of file xmlparse.cc.

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

References _dtd, tag::bindings, dtdReset(), FREE, freeInternalEntities, freeTagList, inheritedBindings, moveToFreeBindingList(), open_internal_entity::next, openInternalEntities, tag::parent, parentParser, geant4_check_module_cycles::parser, parserInit(), poolClear(), tagStack, temp2Pool, tempPool, unknownEncodingData, unknownEncodingMem, unknownEncodingRelease, XML_FALSE, and XML_TRUE.

◆ XML_ResumeParser()

enum XML_Status XMLCALL XML_ResumeParser ( XML_Parser parser )

Definition at line 1796 of file xmlparse.cc.

{
  enum XML_Status result = XML_STATUS_OK;
 
  if (ps_parsing != XML_SUSPENDED) {
    errorCode = XML_ERROR_NOT_SUSPENDED;
    return XML_STATUS_ERROR;
  }
  ps_parsing = XML_PARSING;
 
  errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
 
  if (errorCode != XML_ERROR_NONE) {
    eventEndPtr = eventPtr;
    processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
  else {
    switch (ps_parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED:
    case XML_PARSING:
      if (ps_finalBuffer) {
        ps_parsing = XML_FINISHED;
        return result;
      }
    default: ;
    }
  }
 
  XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
  positionPtr = bufferPtr;
  return result;
}

References bufferPtr, errorCode, errorProcessor, eventEndPtr, eventPtr, parseEndPtr, geant4_check_module_cycles::parser, positionPtr, processor, ps_finalBuffer, ps_parsing, XML_ERROR_NONE, XML_ERROR_NOT_SUSPENDED, XML_FINISHED, XML_INITIALIZED, XML_PARSING, XML_STATUS_ERROR, XML_STATUS_OK, XML_STATUS_SUSPENDED, XML_SUSPENDED, and XmlUpdatePosition.

◆ XML_SetAttlistDeclHandler()

void XMLCALL XML_SetAttlistDeclHandler	(	XML_Parser	parser,
		XML_AttlistDeclHandler	attdecl
	)

Definition at line 1460 of file xmlparse.cc.

{
  attlistDeclHandler = attdecl;
}

References attlistDeclHandler.

◆ XML_SetBase()

enum XML_Status XMLCALL XML_SetBase	(	XML_Parser	parser,
		const XML_Char *	p
	)

Definition at line 1239 of file xmlparse.cc.

{
  if (p) {
    p = poolCopyString(&_dtd->pool, p);
    if (!p)
      return XML_STATUS_ERROR;
    curBase = p;
  }
  else
    curBase = NULL;
  return XML_STATUS_OK;
}

References _dtd, curBase, poolCopyString(), XML_STATUS_ERROR, and XML_STATUS_OK.

◆ XML_SetCdataSectionHandler()

void XMLCALL XML_SetCdataSectionHandler	(	XML_Parser	parser,
		XML_StartCdataSectionHandler	start,
		XML_EndCdataSectionHandler	end
	)

Definition at line 1321 of file xmlparse.cc.

{
  startCdataSectionHandler = start;
  endCdataSectionHandler = end;
}

References endCdataSectionHandler, and startCdataSectionHandler.

◆ XML_SetCharacterDataHandler()

void XMLCALL XML_SetCharacterDataHandler	(	XML_Parser	parser,
		XML_CharacterDataHandler	handler
	)

Definition at line 1300 of file xmlparse.cc.

{
  characterDataHandler = handler;
}

References characterDataHandler.

Referenced by xDataXML_initializeDoc().

◆ XML_SetCommentHandler()

void XMLCALL XML_SetCommentHandler	(	XML_Parser	parser,
		XML_CommentHandler	handler
	)

Definition at line 1314 of file xmlparse.cc.

{
  commentHandler = handler;
}

References commentHandler.

◆ XML_SetDefaultHandler()

void XMLCALL XML_SetDefaultHandler	(	XML_Parser	parser,
		XML_DefaultHandler	handler
	)

Definition at line 1342 of file xmlparse.cc.

{
  defaultHandler = handler;
  defaultExpandInternalEntities = XML_FALSE;
}

References defaultExpandInternalEntities, defaultHandler, and XML_FALSE.

◆ XML_SetDefaultHandlerExpand()

void XMLCALL XML_SetDefaultHandlerExpand	(	XML_Parser	parser,
		XML_DefaultHandler	handler
	)

Definition at line 1350 of file xmlparse.cc.

{
  defaultHandler = handler;
  defaultExpandInternalEntities = XML_TRUE;
}

References defaultExpandInternalEntities, defaultHandler, and XML_TRUE.

◆ XML_SetDoctypeDeclHandler()

void XMLCALL XML_SetDoctypeDeclHandler	(	XML_Parser	parser,
		XML_StartDoctypeDeclHandler	start,
		XML_EndDoctypeDeclHandler	end
	)

Definition at line 1358 of file xmlparse.cc.

{
  startDoctypeDeclHandler = start;
  endDoctypeDeclHandler = end;
}

References endDoctypeDeclHandler, and startDoctypeDeclHandler.

◆ XML_SetElementDeclHandler()

void XMLCALL XML_SetElementDeclHandler	(	XML_Parser	parser,
		XML_ElementDeclHandler	eldecl
	)

Definition at line 1453 of file xmlparse.cc.

{
  elementDeclHandler = eldecl;
}

References elementDeclHandler.

◆ XML_SetElementHandler()

void XMLCALL XML_SetElementHandler	(	XML_Parser	parser,
		XML_StartElementHandler	start,
		XML_EndElementHandler	end
	)

Definition at line 1279 of file xmlparse.cc.

{
  startElementHandler = start;
  endElementHandler = end;
}

References endElementHandler, and startElementHandler.

Referenced by xDataXML_initializeDoc().

◆ XML_SetEncoding()

enum XML_Status XMLCALL XML_SetEncoding	(	XML_Parser	parser,
		const XML_Char *	encodingName
	)

Definition at line 967 of file xmlparse.cc.

{
  /* 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;
}

References poolCopyString(), protocolEncodingName, ps_parsing, tempPool, XML_PARSING, XML_STATUS_ERROR, XML_STATUS_OK, and XML_SUSPENDED.

◆ XML_SetEndCdataSectionHandler()

void XMLCALL XML_SetEndCdataSectionHandler	(	XML_Parser	parser,
		XML_EndCdataSectionHandler	end
	)

Definition at line 1336 of file xmlparse.cc.

                                                              {
  endCdataSectionHandler = end;
}

References endCdataSectionHandler.

◆ XML_SetEndDoctypeDeclHandler()

void XMLCALL XML_SetEndDoctypeDeclHandler	(	XML_Parser	parser,
		XML_EndDoctypeDeclHandler	end
	)

Definition at line 1373 of file xmlparse.cc.

                                                            {
  endDoctypeDeclHandler = end;
}

References endDoctypeDeclHandler.

◆ XML_SetEndElementHandler()

void XMLCALL XML_SetEndElementHandler	(	XML_Parser	parser,
		XML_EndElementHandler	end
	)

Definition at line 1294 of file xmlparse.cc.

                                                    {
  endElementHandler = end;
}

References endElementHandler.

◆ XML_SetEndNamespaceDeclHandler()

void XMLCALL XML_SetEndNamespaceDeclHandler	(	XML_Parser	parser,
		XML_EndNamespaceDeclHandler	end
	)

Definition at line 1408 of file xmlparse.cc.

                                                                {
  endNamespaceDeclHandler = end;
}

References endNamespaceDeclHandler.

◆ XML_SetEntityDeclHandler()

void XMLCALL XML_SetEntityDeclHandler	(	XML_Parser	parser,
		XML_EntityDeclHandler	handler
	)

Definition at line 1467 of file xmlparse.cc.

{
  entityDeclHandler = handler;
}

References entityDeclHandler.

◆ XML_SetExternalEntityRefHandler()

void XMLCALL XML_SetExternalEntityRefHandler	(	XML_Parser	parser,
		XML_ExternalEntityRefHandler	handler
	)

Definition at line 1421 of file xmlparse.cc.

{
  externalEntityRefHandler = handler;
}

References externalEntityRefHandler.

◆ XML_SetExternalEntityRefHandlerArg()

void XMLCALL XML_SetExternalEntityRefHandlerArg	(	XML_Parser	parser,
		void *	arg
	)

Definition at line 1428 of file xmlparse.cc.

{
  if (arg)
    externalEntityRefHandlerArg = (XML_Parser)arg;
  else
    externalEntityRefHandlerArg = parser;
}

References externalEntityRefHandlerArg, and geant4_check_module_cycles::parser.

◆ XML_SetHashSalt()

int XMLCALL XML_SetHashSalt	(	XML_Parser	parser,
		unsigned long	hash_salt
	)

Definition at line 1495 of file xmlparse.cc.

{
  /* 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;
}

References hash_secret_salt, ps_parsing, XML_PARSING, and XML_SUSPENDED.

◆ XML_SetNamespaceDeclHandler()

void XMLCALL XML_SetNamespaceDeclHandler	(	XML_Parser	parser,
		XML_StartNamespaceDeclHandler	start,
		XML_EndNamespaceDeclHandler	end
	)

Definition at line 1393 of file xmlparse.cc.

{
  startNamespaceDeclHandler = start;
  endNamespaceDeclHandler = end;
}

References endNamespaceDeclHandler, and startNamespaceDeclHandler.

◆ XML_SetNotationDeclHandler()

void XMLCALL XML_SetNotationDeclHandler	(	XML_Parser	parser,
		XML_NotationDeclHandler	handler
	)

Definition at line 1386 of file xmlparse.cc.

{
  notationDeclHandler = handler;
}

References notationDeclHandler.

◆ XML_SetNotStandaloneHandler()

void XMLCALL XML_SetNotStandaloneHandler	(	XML_Parser	parser,
		XML_NotStandaloneHandler	handler
	)

Definition at line 1414 of file xmlparse.cc.

{
  notStandaloneHandler = handler;
}

References notStandaloneHandler.

◆ XML_SetParamEntityParsing()

int XMLCALL XML_SetParamEntityParsing	(	XML_Parser	parser,
		enum XML_ParamEntityParsing	peParsing
	)

Definition at line 1480 of file xmlparse.cc.

{
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
    return 0;
#ifdef XML_DTD
  paramEntityParsing = peParsing;
  return 1;
#else
  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
#endif
}

References ps_parsing, XML_PARAM_ENTITY_PARSING_NEVER, XML_PARSING, and XML_SUSPENDED.

◆ XML_SetProcessingInstructionHandler()

void XMLCALL XML_SetProcessingInstructionHandler	(	XML_Parser	parser,
		XML_ProcessingInstructionHandler	handler
	)

Definition at line 1307 of file xmlparse.cc.

{
  processingInstructionHandler = handler;
}

References processingInstructionHandler.

◆ XML_SetReturnNSTriplet()

void XMLCALL XML_SetReturnNSTriplet	(	XML_Parser	parser,
		int	do_nst
	)

Definition at line 1221 of file xmlparse.cc.

{
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
    return;
  ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
}

References ns_triplets, ps_parsing, XML_FALSE, XML_PARSING, XML_SUSPENDED, and XML_TRUE.

◆ XML_SetSkippedEntityHandler()

void XMLCALL XML_SetSkippedEntityHandler	(	XML_Parser	parser,
		XML_SkippedEntityHandler	handler
	)

Definition at line 1437 of file xmlparse.cc.

{
  skippedEntityHandler = handler;
}

References skippedEntityHandler.

◆ XML_SetStartCdataSectionHandler()

void XMLCALL XML_SetStartCdataSectionHandler	(	XML_Parser	parser,
		XML_StartCdataSectionHandler	start
	)

Definition at line 1330 of file xmlparse.cc.

                                                                    {
  startCdataSectionHandler = start;
}

References startCdataSectionHandler.

◆ XML_SetStartDoctypeDeclHandler()

void XMLCALL XML_SetStartDoctypeDeclHandler	(	XML_Parser	parser,
		XML_StartDoctypeDeclHandler	start
	)

Definition at line 1367 of file xmlparse.cc.

                                                                  {
  startDoctypeDeclHandler = start;
}

References startDoctypeDeclHandler.

◆ XML_SetStartElementHandler()

void XMLCALL XML_SetStartElementHandler	(	XML_Parser	parser,
		XML_StartElementHandler	start
	)

Definition at line 1288 of file xmlparse.cc.

                                                          {
  startElementHandler = start;
}

References startElementHandler.

◆ XML_SetStartNamespaceDeclHandler()

void XMLCALL XML_SetStartNamespaceDeclHandler	(	XML_Parser	parser,
		XML_StartNamespaceDeclHandler	start
	)

Definition at line 1402 of file xmlparse.cc.

                                                                      {
  startNamespaceDeclHandler = start;
}

References startNamespaceDeclHandler.

◆ XML_SetUnknownEncodingHandler()

void XMLCALL XML_SetUnknownEncodingHandler	(	XML_Parser	parser,
		XML_UnknownEncodingHandler	handler,
		void *	data
	)

Definition at line 1444 of file xmlparse.cc.

{
  unknownEncodingHandler = handler;
  unknownEncodingHandlerData = data;
}

References unknownEncodingHandler, and unknownEncodingHandlerData.

◆ XML_SetUnparsedEntityDeclHandler()

void XMLCALL XML_SetUnparsedEntityDeclHandler	(	XML_Parser	parser,
		XML_UnparsedEntityDeclHandler	handler
	)

Definition at line 1379 of file xmlparse.cc.

{
  unparsedEntityDeclHandler = handler;
}

References unparsedEntityDeclHandler.

◆ XML_SetUserData()

void XMLCALL XML_SetUserData	(	XML_Parser	parser,
		void *	p
	)

Definition at line 1230 of file xmlparse.cc.

{
  if (handlerArg == userData)
    handlerArg = userData = p;
  else
    userData = p;
}

References handlerArg, and userData.

Referenced by xDataXML_initializeDoc().

◆ XML_SetXmlDeclHandler()

void XMLCALL XML_SetXmlDeclHandler	(	XML_Parser	parser,
		XML_XmlDeclHandler	handler
	)

Definition at line 1474 of file xmlparse.cc.

                                                  {
  xmlDeclHandler = handler;
}

References xmlDeclHandler.

◆ XML_StopParser()

enum XML_Status XMLCALL XML_StopParser	(	XML_Parser	parser,
		XML_Bool	resumable
	)

Definition at line 1766 of file xmlparse.cc.

{
  switch (ps_parsing) {
  case XML_SUSPENDED:
    if (resumable) {
      errorCode = XML_ERROR_SUSPENDED;
      return XML_STATUS_ERROR;
    }
    ps_parsing = XML_FINISHED;
    break;
  case XML_FINISHED:
    errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  default:
    if (resumable) {
#ifdef XML_DTD
      if (isParamEntity) {
        errorCode = XML_ERROR_SUSPEND_PE;
        return XML_STATUS_ERROR;
      }
#endif
      ps_parsing = XML_SUSPENDED;
    }
    else
      ps_parsing = XML_FINISHED;
  }
  return XML_STATUS_OK;
}

References errorCode, ps_parsing, XML_ERROR_FINISHED, XML_ERROR_SUSPEND_PE, XML_ERROR_SUSPENDED, XML_FINISHED, XML_STATUS_ERROR, XML_STATUS_OK, and XML_SUSPENDED.

◆ XML_UseForeignDTD()

enum XML_Error XMLCALL XML_UseForeignDTD	(	XML_Parser	parser,
		XML_Bool	useDTD
	)

Definition at line 1207 of file xmlparse.cc.

{
#ifdef XML_DTD
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
  useForeignDTD = useDTD;
  return XML_ERROR_NONE;
#else
  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
#endif
}

References ps_parsing, XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING, XML_ERROR_FEATURE_REQUIRES_XML_DTD, XML_ERROR_NONE, XML_PARSING, and XML_SUSPENDED.

◆ XML_UseParserAsHandlerArg()

void XMLCALL XML_UseParserAsHandlerArg ( XML_Parser parser )

Definition at line 1201 of file xmlparse.cc.

{
  handlerArg = parser;
}

References handlerArg, and geant4_check_module_cycles::parser.

Variable Documentation

◆ cdataSectionProcessor

Processor cdataSectionProcessor

static

Definition at line 314 of file xmlparse.cc.

Referenced by doContent().

◆ contentProcessor

Processor contentProcessor

static

Definition at line 313 of file xmlparse.cc.

Referenced by cdataSectionProcessor(), doProlog(), and internalEntityProcessor().

◆ epilogProcessor

Processor epilogProcessor

static

Definition at line 322 of file xmlparse.cc.

Referenced by doContent(), and epilogProcessor().

◆ errorProcessor

Processor errorProcessor

static

Definition at line 323 of file xmlparse.cc.

Referenced by XML_Parse(), XML_ParseBuffer(), and XML_ResumeParser().

◆ externalEntityContentProcessor

Processor externalEntityContentProcessor

static

Definition at line 327 of file xmlparse.cc.

Referenced by cdataSectionProcessor(), and externalEntityInitProcessor3().

◆ externalEntityInitProcessor

Processor externalEntityInitProcessor

static

Definition at line 324 of file xmlparse.cc.

Referenced by XML_ExternalEntityParserCreate().

◆ externalEntityInitProcessor2

Processor externalEntityInitProcessor2

static

Definition at line 325 of file xmlparse.cc.

Referenced by externalEntityInitProcessor().

◆ externalEntityInitProcessor3

Processor externalEntityInitProcessor3

static

Definition at line 326 of file xmlparse.cc.

Referenced by externalEntityInitProcessor2().

◆ implicitContext

const XML_Char implicitContext[]

static

Initial value:

= {
  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'
}

Definition at line 690 of file xmlparse.cc.

Referenced by startParsing().

◆ internalEntityProcessor

Processor internalEntityProcessor

static

Definition at line 328 of file xmlparse.cc.

Referenced by processInternalEntity().

◆ prologInitProcessor

Processor prologInitProcessor

static

Definition at line 312 of file xmlparse.cc.

Referenced by parserInit().

◆ prologProcessor

Processor prologProcessor

static

Definition at line 311 of file xmlparse.cc.

Referenced by internalEntityProcessor(), and prologInitProcessor().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _dtd

◆ attInfo

◆ attlistDeclHandler

◆ atts

◆ attsSize

◆ buffer

◆ bufferEnd

◆ bufferLim

◆ bufferPtr

◆ CHAR_HASH

◆ characterDataHandler

◆ commentHandler

◆ CONTEXT_SEP

◆ curBase

◆ dataBuf

◆ dataBufEnd

◆ declAttributeId

◆ declAttributeIsCdata

◆ declAttributeIsId

◆ declAttributeType

◆ declElementType

◆ declEntity

◆ declNotationName

◆ declNotationPublicId

◆ defaultExpandInternalEntities

◆ defaultHandler

◆ doctypeName

◆ doctypePubid

◆ doctypeSysid

◆ elementDeclHandler

◆ encoding

◆ endCdataSectionHandler

◆ endDoctypeDeclHandler

◆ endElementHandler

◆ endNamespaceDeclHandler

◆ entityDeclHandler

◆ errorCode

◆ eventEndPtr

◆ eventPtr

◆ EXPAND_SPARE

◆ externalEntityRefHandler

◆ externalEntityRefHandlerArg

◆ FREE

◆ freeBindingList

◆ freeInternalEntities

◆ freeTagList

◆ groupConnector

◆ groupSize

◆ handlerArg

◆ hash_secret_salt

◆ idAttIndex

◆ inheritedBindings

◆ INIT_ATTS_SIZE

◆ INIT_ATTS_VERSION

◆ INIT_BLOCK_SIZE

◆ INIT_BUFFER_SIZE

◆ INIT_DATA_BUF_SIZE

◆ INIT_POWER

◆ INIT_SCAFFOLD_ELEMENTS

◆ INIT_TAG_BUF_SIZE

◆ initEncoding

◆ internalEncoding

◆ internalEntityRefHandler

◆ MALLOC

◆ MUST_CONVERT

◆ namespaceSeparator

◆ notationDeclHandler

◆ notStandaloneHandler

◆ ns

◆ ns_triplets

◆ nsAtts

◆ nsAttsPower

◆ nsAttsVersion

◆ nSpecifiedAtts