xmlparse.c File Reference

#include <expat_config.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include "ascii.h"
#include "expat.h"
#include "siphash.h"
#include "internal.h"
#include "xmltok.h"
#include "xmlrole.h"

Go to the source code of this file.

Classes
struct	NAMED
struct	HASH_TABLE
struct	HASH_TABLE_ITER
struct	binding
struct	prefix
struct	TAG_NAME
struct	tag
struct	ENTITY
struct	CONTENT_SCAFFOLD
struct	block
struct	STRING_POOL
struct	attribute_id
struct	DEFAULT_ATTRIBUTE
struct	NS_ATT
struct	ELEMENT_TYPE
struct	DTD
struct	open_internal_entity
struct	XML_ParserStruct

Macros
#define	XML_BUILDING_EXPAT   1
#define	_GNU_SOURCE   1 /* syscall prototype */
#define	XML_ENCODE_MAX   XML_UTF8_ENCODE_MAX
#define	XmlConvert   XmlUtf8Convert
#define	XmlGetInternalEncoding   XmlGetUtf8InternalEncoding
#define	XmlGetInternalEncodingNS   XmlGetUtf8InternalEncodingNS
#define	XmlEncode   XmlUtf8Encode
#define	MUST_CONVERT(enc, s)   (! (enc)->isUtf8)
#define	XmlInitEncodingNS   XmlInitEncoding
#define	XmlInitUnknownEncodingNS   XmlInitUnknownEncoding
#define	XmlGetInternalEncodingNS   XmlGetInternalEncoding
#define	XmlParseXmlDeclNS   XmlParseXmlDecl
#define	XML_T(x)   x
#define	XML_L(x)   x
#define	ROUND_UP(n, sz)   (((n) + ((sz)-1)) & ~((sz)-1))
#define	EXPAT_SAFE_PTR_DIFF(p, q)   (((p) && (q)) ? ((p) - (q)) : 0)
#define	SECOND_HASH(hash, mask, power)    ((((hash) & ~(mask)) >> ((power)-1)) & ((mask) >> 2))
#define	PROBE_STEP(hash, mask, power)    ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
#define	INIT_TAG_BUF_SIZE   32 /* must be a multiple of sizeof(XML_Char) */
#define	INIT_DATA_BUF_SIZE   1024
#define	INIT_ATTS_SIZE   16
#define	INIT_ATTS_VERSION   0xFFFFFFFF
#define	INIT_BLOCK_SIZE   1024
#define	INIT_BUFFER_SIZE   1024
#define	EXPAND_SPARE   24
#define	INIT_SCAFFOLD_ELEMENTS   32
#define	poolStart(pool)   ((pool)->start)
#define	poolEnd(pool)   ((pool)->ptr)
#define	poolLength(pool)   ((pool)->ptr - (pool)->start)
#define	poolChop(pool)   ((void)--(pool->ptr))
#define	poolLastChar(pool)   (((pool)->ptr)[-1])
#define	poolDiscard(pool)   ((pool)->ptr = (pool)->start)
#define	poolFinish(pool)   ((pool)->start = (pool)->ptr)
#define	poolAppendChar(pool, c)
#define	MALLOC(parser, s)   (parser->m_mem.malloc_fcn((s)))
#define	REALLOC(parser, p, s)   (parser->m_mem.realloc_fcn((p), (s)))
#define	FREE(parser, p)   (parser->m_mem.free_fcn((p)))
#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	CONTEXT_SEP   XML_T(ASCII_FF)
#define	INIT_POWER   6

Typedefs
typedef char	ICHAR
typedef const XML_Char *	KEY
typedef struct binding	BINDING
typedef struct prefix	PREFIX
typedef struct tag	TAG
typedef struct block	BLOCK
typedef struct attribute_id	ATTRIBUTE_ID
typedef struct open_internal_entity	OPEN_INTERNAL_ENTITY

Enumerations
enum	XML_Account { XML_ACCOUNT_DIRECT , XML_ACCOUNT_ENTITY_EXPANSION , XML_ACCOUNT_NONE }

Functions
enum XML_Error PTRCALL	Processor (XML_Parser parser, const char *start, const char *end, const char **endPtr)
XML_Parser XMLCALL	XML_ParserCreate (const XML_Char *encodingName)
XML_Parser XMLCALL	XML_ParserCreateNS (const XML_Char *encodingName, XML_Char nsSep)
XML_Parser XMLCALL	XML_ParserCreate_MM (const XML_Char *encodingName, const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep)
XML_Bool XMLCALL	XML_ParserReset (XML_Parser parser, const XML_Char *encodingName)
enum XML_Status XMLCALL	XML_SetEncoding (XML_Parser parser, const XML_Char *encodingName)
XML_Parser XMLCALL	XML_ExternalEntityParserCreate (XML_Parser oldParser, const XML_Char *context, const XML_Char *encodingName)
void XMLCALL	XML_ParserFree (XML_Parser parser)
void XMLCALL	XML_UseParserAsHandlerArg (XML_Parser parser)
enum XML_Error XMLCALL	XML_UseForeignDTD (XML_Parser parser, XML_Bool useDTD)
void XMLCALL	XML_SetReturnNSTriplet (XML_Parser parser, int do_nst)
void XMLCALL	XML_SetUserData (XML_Parser parser, void *p)
enum XML_Status XMLCALL	XML_SetBase (XML_Parser parser, const XML_Char *p)
const XML_Char *XMLCALL	XML_GetBase (XML_Parser parser)
int XMLCALL	XML_GetSpecifiedAttributeCount (XML_Parser parser)
int XMLCALL	XML_GetIdAttributeIndex (XML_Parser parser)
void XMLCALL	XML_SetElementHandler (XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)
void XMLCALL	XML_SetStartElementHandler (XML_Parser parser, XML_StartElementHandler start)
void XMLCALL	XML_SetEndElementHandler (XML_Parser parser, XML_EndElementHandler end)
void XMLCALL	XML_SetCharacterDataHandler (XML_Parser parser, XML_CharacterDataHandler handler)
void XMLCALL	XML_SetProcessingInstructionHandler (XML_Parser parser, XML_ProcessingInstructionHandler handler)
void XMLCALL	XML_SetCommentHandler (XML_Parser parser, XML_CommentHandler handler)
void XMLCALL	XML_SetCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end)
void XMLCALL	XML_SetStartCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start)
void XMLCALL	XML_SetEndCdataSectionHandler (XML_Parser parser, XML_EndCdataSectionHandler end)
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_SetStartDoctypeDeclHandler (XML_Parser parser, XML_StartDoctypeDeclHandler start)
void XMLCALL	XML_SetEndDoctypeDeclHandler (XML_Parser parser, XML_EndDoctypeDeclHandler end)
void XMLCALL	XML_SetUnparsedEntityDeclHandler (XML_Parser parser, XML_UnparsedEntityDeclHandler handler)
void XMLCALL	XML_SetNotationDeclHandler (XML_Parser parser, XML_NotationDeclHandler handler)
void XMLCALL	XML_SetNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end)
void XMLCALL	XML_SetStartNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start)
void XMLCALL	XML_SetEndNamespaceDeclHandler (XML_Parser parser, XML_EndNamespaceDeclHandler end)
void XMLCALL	XML_SetNotStandaloneHandler (XML_Parser parser, XML_NotStandaloneHandler handler)
void XMLCALL	XML_SetExternalEntityRefHandler (XML_Parser parser, XML_ExternalEntityRefHandler handler)
void XMLCALL	XML_SetExternalEntityRefHandlerArg (XML_Parser parser, void *arg)
void XMLCALL	XML_SetSkippedEntityHandler (XML_Parser parser, XML_SkippedEntityHandler handler)
void XMLCALL	XML_SetUnknownEncodingHandler (XML_Parser parser, XML_UnknownEncodingHandler handler, void *data)
void XMLCALL	XML_SetElementDeclHandler (XML_Parser parser, XML_ElementDeclHandler eldecl)
void XMLCALL	XML_SetAttlistDeclHandler (XML_Parser parser, XML_AttlistDeclHandler attdecl)
void XMLCALL	XML_SetEntityDeclHandler (XML_Parser parser, XML_EntityDeclHandler handler)
void XMLCALL	XML_SetXmlDeclHandler (XML_Parser parser, XML_XmlDeclHandler handler)
int XMLCALL	XML_SetParamEntityParsing (XML_Parser parser, enum XML_ParamEntityParsing peParsing)
int XMLCALL	XML_SetHashSalt (XML_Parser parser, unsigned long hash_salt)
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)
void *XMLCALL	XML_GetBuffer (XML_Parser parser, int len)
enum XML_Status XMLCALL	XML_StopParser (XML_Parser parser, XML_Bool resumable)
enum XML_Status XMLCALL	XML_ResumeParser (XML_Parser parser)
void XMLCALL	XML_GetParsingStatus (XML_Parser parser, XML_ParsingStatus *status)
enum XML_Error XMLCALL	XML_GetErrorCode (XML_Parser parser)
XML_Index XMLCALL	XML_GetCurrentByteIndex (XML_Parser parser)
int XMLCALL	XML_GetCurrentByteCount (XML_Parser parser)
const char *XMLCALL	XML_GetInputContext (XML_Parser parser, int *offset, int *size)
XML_Size XMLCALL	XML_GetCurrentLineNumber (XML_Parser parser)
XML_Size XMLCALL	XML_GetCurrentColumnNumber (XML_Parser parser)
void XMLCALL	XML_FreeContentModel (XML_Parser parser, XML_Content *model)
void *XMLCALL	XML_MemMalloc (XML_Parser parser, size_t size)
void *XMLCALL	XML_MemRealloc (XML_Parser parser, void *ptr, size_t size)
void XMLCALL	XML_MemFree (XML_Parser parser, void *ptr)
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)
const XML_Feature *XMLCALL	XML_GetFeatureList (void)

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE   1 /* syscall prototype */

Definition at line 65 of file xmlparse.c.

CONTEXT_SEP

#define CONTEXT_SEP   XML_T(ASCII_FF)

Definition at line 6516 of file xmlparse.c.

EXPAND_SPARE

#define EXPAND_SPARE   24

Definition at line 245 of file xmlparse.c.

EXPAT_SAFE_PTR_DIFF

#define EXPAT_SAFE_PTR_DIFF	(		p,
			q
	)		(((p) && (q)) ? ((p) - (q)) : 0)

Definition at line 196 of file xmlparse.c.

FREE

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

Definition at line 713 of file xmlparse.c.

INIT_ATTS_SIZE

#define INIT_ATTS_SIZE   16

Definition at line 240 of file xmlparse.c.

INIT_ATTS_VERSION

#define INIT_ATTS_VERSION   0xFFFFFFFF

Definition at line 241 of file xmlparse.c.

INIT_BLOCK_SIZE

#define INIT_BLOCK_SIZE   1024

Definition at line 242 of file xmlparse.c.

INIT_BUFFER_SIZE

#define INIT_BUFFER_SIZE   1024

Definition at line 243 of file xmlparse.c.

INIT_DATA_BUF_SIZE

#define INIT_DATA_BUF_SIZE   1024

Definition at line 239 of file xmlparse.c.

INIT_POWER

#define INIT_POWER   6

Definition at line 6987 of file xmlparse.c.

INIT_SCAFFOLD_ELEMENTS

#define INIT_SCAFFOLD_ELEMENTS   32

Definition at line 318 of file xmlparse.c.

INIT_TAG_BUF_SIZE

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

Definition at line 238 of file xmlparse.c.

MALLOC

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

Definition at line 711 of file xmlparse.c.

MUST_CONVERT

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

Definition at line 161 of file xmlparse.c.

poolAppendChar

#define poolAppendChar	(		pool,
			c
	)

Value:

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

Definition at line 599 of file xmlparse.c.

poolChop

#define poolChop

(

pool

)

((void)--(pool->ptr))

Definition at line 595 of file xmlparse.c.

poolDiscard

#define poolDiscard

(

pool

)

((pool)->ptr = (pool)->start)

Definition at line 597 of file xmlparse.c.

poolEnd

#define poolEnd

(

pool

)

((pool)->ptr)

Definition at line 593 of file xmlparse.c.

poolFinish

#define poolFinish

(

pool

)

((pool)->start = (pool)->ptr)

Definition at line 598 of file xmlparse.c.

poolLastChar

#define poolLastChar

(

pool

)

(((pool)->ptr)[-1])

Definition at line 596 of file xmlparse.c.

poolLength

#define poolLength

(

pool

)

((pool)->ptr - (pool)->start)

Definition at line 594 of file xmlparse.c.

poolStart

#define poolStart

(

pool

)

((pool)->start)

Definition at line 592 of file xmlparse.c.

PROBE_STEP

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

Definition at line 230 of file xmlparse.c.

REALLOC

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

Definition at line 712 of file xmlparse.c.

ROUND_UP

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

Definition at line 193 of file xmlparse.c.

SECOND_HASH

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

Definition at line 228 of file xmlparse.c.

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 60 of file xmlparse.c.

XML_ENCODE_MAX

#define XML_ENCODE_MAX   XML_UTF8_ENCODE_MAX

Definition at line 156 of file xmlparse.c.

XML_L

#define XML_L

(

x

)

x

Definition at line 188 of file xmlparse.c.

XML_T

#define XML_T

(

x

)

x

Definition at line 187 of file xmlparse.c.

XmlConvert

#define XmlConvert   XmlUtf8Convert

Definition at line 157 of file xmlparse.c.

XmlEncode

#define XmlEncode   XmlUtf8Encode

Definition at line 160 of file xmlparse.c.

XmlGetInternalEncoding

#define XmlGetInternalEncoding   XmlGetUtf8InternalEncoding

Definition at line 158 of file xmlparse.c.

XmlGetInternalEncodingNS [1/2]

#define XmlGetInternalEncodingNS   XmlGetUtf8InternalEncodingNS

Definition at line 170 of file xmlparse.c.

XmlGetInternalEncodingNS [2/2]

#define XmlGetInternalEncodingNS   XmlGetInternalEncoding

Definition at line 170 of file xmlparse.c.

XmlInitEncodingNS

#define XmlInitEncodingNS   XmlInitEncoding

Definition at line 167 of file xmlparse.c.

XmlInitUnknownEncodingNS

#define XmlInitUnknownEncodingNS   XmlInitUnknownEncoding

Definition at line 168 of file xmlparse.c.

XmlParseXmlDeclNS

#define XmlParseXmlDeclNS   XmlParseXmlDecl

Definition at line 171 of file xmlparse.c.

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 162 of file xmlparse.c.

KEY

typedef const XML_Char* KEY

Definition at line 202 of file xmlparse.c.

OPEN_INTERNAL_ENTITY

typedef struct open_internal_entity OPEN_INTERNAL_ENTITY

PREFIX

typedef struct prefix PREFIX

TAG

typedef struct tag TAG

Enumeration Type Documentation

XML_Account

enum XML_Account

Enumerator
XML_ACCOUNT_DIRECT
XML_ACCOUNT_ENTITY_EXPANSION
XML_ACCOUNT_NONE

Definition at line 403 of file xmlparse.c.

                 {
  XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
  XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
                                   expansion */
  XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */
};

Function Documentation

Processor()

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

XML_DefaultCurrent()

void XMLCALL XML_DefaultCurrent

(

XML_Parser

parser

)

Definition at line 2335 of file xmlparse.c.

                                      {
  if (parser == NULL)
    return;
  if (parser->m_defaultHandler) {
    if (parser->m_openInternalEntities)
      reportDefault(parser, parser->m_internalEncoding,
                    parser->m_openInternalEntities->internalEventPtr,
                    parser->m_openInternalEntities->internalEventEndPtr);
    else
      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
                    parser->m_eventEndPtr);
  }
}

XML_ErrorString()

const XML_LChar *XMLCALL XML_ErrorString

(

enum XML_Error

code

)

Definition at line 2350 of file xmlparse.c.

                                     {
  switch (code) {
  case XML_ERROR_NONE:
    return NULL;
  case XML_ERROR_NO_MEMORY:
    return XML_L("out of memory");
  case XML_ERROR_SYNTAX:
    return XML_L("syntax error");
  case XML_ERROR_NO_ELEMENTS:
    return XML_L("no element found");
  case XML_ERROR_INVALID_TOKEN:
    return XML_L("not well-formed (invalid token)");
  case XML_ERROR_UNCLOSED_TOKEN:
    return XML_L("unclosed token");
  case XML_ERROR_PARTIAL_CHAR:
    return XML_L("partial character");
  case XML_ERROR_TAG_MISMATCH:
    return XML_L("mismatched tag");
  case XML_ERROR_DUPLICATE_ATTRIBUTE:
    return XML_L("duplicate attribute");
  case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
    return XML_L("junk after document element");
  case XML_ERROR_PARAM_ENTITY_REF:
    return XML_L("illegal parameter entity reference");
  case XML_ERROR_UNDEFINED_ENTITY:
    return XML_L("undefined entity");
  case XML_ERROR_RECURSIVE_ENTITY_REF:
    return XML_L("recursive entity reference");
  case XML_ERROR_ASYNC_ENTITY:
    return XML_L("asynchronous entity");
  case XML_ERROR_BAD_CHAR_REF:
    return XML_L("reference to invalid character number");
  case XML_ERROR_BINARY_ENTITY_REF:
    return XML_L("reference to binary entity");
  case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
    return XML_L("reference to external entity in attribute");
  case XML_ERROR_MISPLACED_XML_PI:
    return XML_L("XML or text declaration not at start of entity");
  case XML_ERROR_UNKNOWN_ENCODING:
    return XML_L("unknown encoding");
  case XML_ERROR_INCORRECT_ENCODING:
    return XML_L("encoding specified in XML declaration is incorrect");
  case XML_ERROR_UNCLOSED_CDATA_SECTION:
    return XML_L("unclosed CDATA section");
  case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
    return XML_L("error in processing external entity reference");
  case XML_ERROR_NOT_STANDALONE:
    return XML_L("document is not standalone");
  case XML_ERROR_UNEXPECTED_STATE:
    return XML_L("unexpected parser state - please send a bug report");
  case XML_ERROR_ENTITY_DECLARED_IN_PE:
    return XML_L("entity declared in parameter entity");
  case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
    return XML_L("requested feature requires XML_DTD support in Expat");
  case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
    return XML_L("cannot change setting once parsing has begun");
  /* Added in 1.95.7. */
  case XML_ERROR_UNBOUND_PREFIX:
    return XML_L("unbound prefix");
  /* Added in 1.95.8. */
  case XML_ERROR_UNDECLARING_PREFIX:
    return XML_L("must not undeclare prefix");
  case XML_ERROR_INCOMPLETE_PE:
    return XML_L("incomplete markup in parameter entity");
  case XML_ERROR_XML_DECL:
    return XML_L("XML declaration not well-formed");
  case XML_ERROR_TEXT_DECL:
    return XML_L("text declaration not well-formed");
  case XML_ERROR_PUBLICID:
    return XML_L("illegal character(s) in public id");
  case XML_ERROR_SUSPENDED:
    return XML_L("parser suspended");
  case XML_ERROR_NOT_SUSPENDED:
    return XML_L("parser not suspended");
  case XML_ERROR_ABORTED:
    return XML_L("parsing aborted");
  case XML_ERROR_FINISHED:
    return XML_L("parsing finished");
  case XML_ERROR_SUSPEND_PE:
    return XML_L("cannot suspend in external parameter entity");
  /* Added in 2.0.0. */
  case XML_ERROR_RESERVED_PREFIX_XML:
    return XML_L(
        "reserved prefix (xml) must not be undeclared or bound to another namespace name");
  case XML_ERROR_RESERVED_PREFIX_XMLNS:
    return XML_L("reserved prefix (xmlns) must not be declared or undeclared");
  case XML_ERROR_RESERVED_NAMESPACE_URI:
    return XML_L(
        "prefix must not be bound to one of the reserved namespace names");
  /* Added in 2.2.5. */
  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
    return XML_L("invalid argument");
    /* Added in 2.3.0. */
  case XML_ERROR_NO_BUFFER:
    return XML_L(
        "a successful prior call to function XML_GetBuffer is required");
  /* Added in 2.4.0. */
  case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:
    return XML_L(
        "limit on input amplification factor (from DTD and entities) breached");
  }
  return NULL;
}

XML_ExpatVersion()

const XML_LChar *XMLCALL XML_ExpatVersion

(

void

)

Definition at line 2455 of file xmlparse.c.

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

XML_ExpatVersionInfo()

XML_Expat_Version XMLCALL XML_ExpatVersionInfo

(

void

)

Definition at line 2474 of file xmlparse.c.

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

XML_ExternalEntityParserCreate()

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

Definition at line 1250 of file xmlparse.c.

                                                             {
  XML_Parser parser = oldParser;
  DTD *newDtd = NULL;
  DTD *oldDtd;
  XML_StartElementHandler oldStartElementHandler;
  XML_EndElementHandler oldEndElementHandler;
  XML_CharacterDataHandler oldCharacterDataHandler;
  XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
  XML_CommentHandler oldCommentHandler;
  XML_StartCdataSectionHandler oldStartCdataSectionHandler;
  XML_EndCdataSectionHandler oldEndCdataSectionHandler;
  XML_DefaultHandler oldDefaultHandler;
  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
  XML_NotationDeclHandler oldNotationDeclHandler;
  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
  XML_NotStandaloneHandler oldNotStandaloneHandler;
  XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
  XML_SkippedEntityHandler oldSkippedEntityHandler;
  XML_UnknownEncodingHandler oldUnknownEncodingHandler;
  XML_ElementDeclHandler oldElementDeclHandler;
  XML_AttlistDeclHandler oldAttlistDeclHandler;
  XML_EntityDeclHandler oldEntityDeclHandler;
  XML_XmlDeclHandler oldXmlDeclHandler;
  ELEMENT_TYPE *oldDeclElementType;
 
  void *oldUserData;
  void *oldHandlerArg;
  XML_Bool oldDefaultExpandInternalEntities;
  XML_Parser oldExternalEntityRefHandlerArg;
#ifdef XML_DTD
  enum XML_ParamEntityParsing oldParamEntityParsing;
  int oldInEntityValue;
#endif
  XML_Bool oldns_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;
 
  /* Validate the oldParser parameter before we pull everything out of it */
  if (oldParser == NULL)
    return NULL;
 
  /* Stash the original parser contents on the stack */
  oldDtd = parser->m_dtd;
  oldStartElementHandler = parser->m_startElementHandler;
  oldEndElementHandler = parser->m_endElementHandler;
  oldCharacterDataHandler = parser->m_characterDataHandler;
  oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
  oldCommentHandler = parser->m_commentHandler;
  oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
  oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
  oldDefaultHandler = parser->m_defaultHandler;
  oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
  oldNotationDeclHandler = parser->m_notationDeclHandler;
  oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
  oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
  oldNotStandaloneHandler = parser->m_notStandaloneHandler;
  oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
  oldSkippedEntityHandler = parser->m_skippedEntityHandler;
  oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
  oldElementDeclHandler = parser->m_elementDeclHandler;
  oldAttlistDeclHandler = parser->m_attlistDeclHandler;
  oldEntityDeclHandler = parser->m_entityDeclHandler;
  oldXmlDeclHandler = parser->m_xmlDeclHandler;
  oldDeclElementType = parser->m_declElementType;
 
  oldUserData = parser->m_userData;
  oldHandlerArg = parser->m_handlerArg;
  oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
  oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
#ifdef XML_DTD
  oldParamEntityParsing = parser->m_paramEntityParsing;
  oldInEntityValue = parser->m_prologState.inEntityValue;
#endif
  oldns_triplets = parser->m_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.
  */
  oldhash_secret_salt = parser->m_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 (parser->m_ns) {
    XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
  } else {
    parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
  }
 
  if (! parser)
    return NULL;
 
  parser->m_startElementHandler = oldStartElementHandler;
  parser->m_endElementHandler = oldEndElementHandler;
  parser->m_characterDataHandler = oldCharacterDataHandler;
  parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
  parser->m_commentHandler = oldCommentHandler;
  parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
  parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
  parser->m_defaultHandler = oldDefaultHandler;
  parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
  parser->m_notationDeclHandler = oldNotationDeclHandler;
  parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
  parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
  parser->m_notStandaloneHandler = oldNotStandaloneHandler;
  parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
  parser->m_skippedEntityHandler = oldSkippedEntityHandler;
  parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
  parser->m_elementDeclHandler = oldElementDeclHandler;
  parser->m_attlistDeclHandler = oldAttlistDeclHandler;
  parser->m_entityDeclHandler = oldEntityDeclHandler;
  parser->m_xmlDeclHandler = oldXmlDeclHandler;
  parser->m_declElementType = oldDeclElementType;
  parser->m_userData = oldUserData;
  if (oldUserData == oldHandlerArg)
    parser->m_handlerArg = parser->m_userData;
  else
    parser->m_handlerArg = parser;
  if (oldExternalEntityRefHandlerArg != oldParser)
    parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
  parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
  parser->m_ns_triplets = oldns_triplets;
  parser->m_hash_secret_salt = oldhash_secret_salt;
  parser->m_parentParser = oldParser;
#ifdef XML_DTD
  parser->m_paramEntityParsing = oldParamEntityParsing;
  parser->m_prologState.inEntityValue = oldInEntityValue;
  if (context) {
#endif /* XML_DTD */
    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
        || ! setContext(parser, context)) {
      XML_ParserFree(parser);
      return NULL;
    }
    parser->m_processor = externalEntityInitProcessor;
#ifdef XML_DTD
  } else {
    /* The DTD instance referenced by parser->m_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 parser->m_dtd with ones that get destroyed with the external
       PE parser. This would leave those prefixes with dangling pointers.
    */
    parser->m_isParamEntity = XML_TRUE;
    XmlPrologStateInitExternalEntity(&parser->m_prologState);
    parser->m_processor = externalParEntInitProcessor;
  }
#endif /* XML_DTD */
  return parser;
}

XML_FreeContentModel()

void XMLCALL XML_FreeContentModel	(	XML_Parser	parser,
		XML_Content *	model
	)

Definition at line 2309 of file xmlparse.c.

                                                            {
  if (parser != NULL)
    FREE(parser, model);
}

XML_GetBase()

const XML_Char *XMLCALL XML_GetBase

(

XML_Parser

parser

)

Definition at line 1554 of file xmlparse.c.

                               {
  if (parser == NULL)
    return NULL;
  return parser->m_curBase;
}

XML_GetBuffer()

void *XMLCALL XML_GetBuffer	(	XML_Parser	parser,
		int	len
	)

Definition at line 2038 of file xmlparse.c.

                                          {
  if (parser == NULL)
    return NULL;
  if (len < 0) {
    parser->m_errorCode = XML_ERROR_NO_MEMORY;
    return NULL;
  }
  switch (parser->m_parsingStatus.parsing) {
  case XML_SUSPENDED:
    parser->m_errorCode = XML_ERROR_SUSPENDED;
    return NULL;
  case XML_FINISHED:
    parser->m_errorCode = XML_ERROR_FINISHED;
    return NULL;
  default:;
  }
 
  if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
#ifdef XML_CONTEXT_BYTES
    int keep;
#endif /* defined XML_CONTEXT_BYTES */
    /* Do not invoke signed arithmetic overflow: */
    int neededSize = (int)((unsigned)len
                           + (unsigned)EXPAT_SAFE_PTR_DIFF(
                               parser->m_bufferEnd, parser->m_bufferPtr));
    if (neededSize < 0) {
      parser->m_errorCode = XML_ERROR_NO_MEMORY;
      return NULL;
    }
#ifdef XML_CONTEXT_BYTES
    keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
    if (keep > XML_CONTEXT_BYTES)
      keep = XML_CONTEXT_BYTES;
    /* Detect and prevent integer overflow */
    if (keep > INT_MAX - neededSize) {
      parser->m_errorCode = XML_ERROR_NO_MEMORY;
      return NULL;
    }
    neededSize += keep;
#endif /* defined XML_CONTEXT_BYTES */
    if (neededSize
        <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
#ifdef XML_CONTEXT_BYTES
      if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
        int offset
            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
              - keep;
        /* The buffer pointers cannot be NULL here; we have at least some bytes
         * in the buffer */
        memmove(parser->m_buffer, &parser->m_buffer[offset],
                parser->m_bufferEnd - parser->m_bufferPtr + keep);
        parser->m_bufferEnd -= offset;
        parser->m_bufferPtr -= offset;
      }
#else
      if (parser->m_buffer && parser->m_bufferPtr) {
        memmove(parser->m_buffer, parser->m_bufferPtr,
                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
        parser->m_bufferEnd
            = parser->m_buffer
              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
        parser->m_bufferPtr = parser->m_buffer;
      }
#endif /* not defined XML_CONTEXT_BYTES */
    } else {
      char *newBuf;
      int bufferSize
          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
      if (bufferSize == 0)
        bufferSize = INIT_BUFFER_SIZE;
      do {
        /* Do not invoke signed arithmetic overflow: */
        bufferSize = (int)(2U * (unsigned)bufferSize);
      } while (bufferSize < neededSize && bufferSize > 0);
      if (bufferSize <= 0) {
        parser->m_errorCode = XML_ERROR_NO_MEMORY;
        return NULL;
      }
      newBuf = (char *)MALLOC(parser, bufferSize);
      if (newBuf == 0) {
        parser->m_errorCode = XML_ERROR_NO_MEMORY;
        return NULL;
      }
      parser->m_bufferLim = newBuf + bufferSize;
#ifdef XML_CONTEXT_BYTES
      if (parser->m_bufferPtr) {
        memcpy(newBuf, &parser->m_bufferPtr[-keep],
               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
                   + keep);
        FREE(parser, parser->m_buffer);
        parser->m_buffer = newBuf;
        parser->m_bufferEnd
            = parser->m_buffer
              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
              + keep;
        parser->m_bufferPtr = parser->m_buffer + keep;
      } else {
        /* This must be a brand new buffer with no data in it yet */
        parser->m_bufferEnd = newBuf;
        parser->m_bufferPtr = parser->m_buffer = newBuf;
      }
#else
      if (parser->m_bufferPtr) {
        memcpy(newBuf, parser->m_bufferPtr,
               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
        FREE(parser, parser->m_buffer);
        parser->m_bufferEnd
            = newBuf
              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
      } else {
        /* This must be a brand new buffer with no data in it yet */
        parser->m_bufferEnd = newBuf;
      }
      parser->m_bufferPtr = parser->m_buffer = newBuf;
#endif /* not defined XML_CONTEXT_BYTES */
    }
    parser->m_eventPtr = parser->m_eventEndPtr = NULL;
    parser->m_positionPtr = NULL;
  }
  return parser->m_bufferEnd;
}

Referenced by XML_Parse().

XML_GetCurrentByteCount()

int XMLCALL XML_GetCurrentByteCount

(

XML_Parser

parser

)

Definition at line 2256 of file xmlparse.c.

                                           {
  if (parser == NULL)
    return 0;
  if (parser->m_eventEndPtr && parser->m_eventPtr)
    return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
  return 0;
}

XML_GetCurrentByteIndex()

XML_Index XMLCALL XML_GetCurrentByteIndex

(

XML_Parser

parser

)

Definition at line 2246 of file xmlparse.c.

                                           {
  if (parser == NULL)
    return -1;
  if (parser->m_eventPtr)
    return (XML_Index)(parser->m_parseEndByteIndex
                       - (parser->m_parseEndPtr - parser->m_eventPtr));
  return -1;
}

XML_GetCurrentColumnNumber()

XML_Size XMLCALL XML_GetCurrentColumnNumber

(

XML_Parser

parser

)

Definition at line 2297 of file xmlparse.c.

                                              {
  if (parser == NULL)
    return 0;
  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
                      parser->m_eventPtr, &parser->m_position);
    parser->m_positionPtr = parser->m_eventPtr;
  }
  return parser->m_position.columnNumber;
}

XML_GetCurrentLineNumber()

XML_Size XMLCALL XML_GetCurrentLineNumber

(

XML_Parser

parser

)

Definition at line 2285 of file xmlparse.c.

                                            {
  if (parser == NULL)
    return 0;
  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
                      parser->m_eventPtr, &parser->m_position);
    parser->m_positionPtr = parser->m_eventPtr;
  }
  return parser->m_position.lineNumber + 1;
}

XML_GetErrorCode()

enum XML_Error XMLCALL XML_GetErrorCode

(

XML_Parser

parser

)

Definition at line 2239 of file xmlparse.c.

                                    {
  if (parser == NULL)
    return XML_ERROR_INVALID_ARGUMENT;
  return parser->m_errorCode;
}

XML_GetFeatureList()

const XML_Feature *XMLCALL XML_GetFeatureList

(

void

)

Definition at line 2485 of file xmlparse.c.

                         {
  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
#ifdef XML_DTD
      /* Added in Expat 2.4.0. */
      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
       XML_L("XML_BLAP_MAX_AMP"),
       (long int)
           EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},
      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,
       XML_L("XML_BLAP_ACT_THRES"),
       EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},
#endif
      {XML_FEATURE_END, NULL, 0}};
 
  return features;
}

XML_GetIdAttributeIndex()

int XMLCALL XML_GetIdAttributeIndex

(

XML_Parser

parser

)

Definition at line 1568 of file xmlparse.c.

                                           {
  if (parser == NULL)
    return -1;
  return parser->m_idAttIndex;
}

XML_GetInputContext()

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

Definition at line 2265 of file xmlparse.c.

                                                               {
#ifdef XML_CONTEXT_BYTES
  if (parser == NULL)
    return NULL;
  if (parser->m_eventPtr && parser->m_buffer) {
    if (offset != NULL)
      *offset = (int)(parser->m_eventPtr - parser->m_buffer);
    if (size != NULL)
      *size = (int)(parser->m_bufferEnd - parser->m_buffer);
    return parser->m_buffer;
  }
#else
  (void)parser;
  (void)offset;
  (void)size;
#endif /* defined XML_CONTEXT_BYTES */
  return (const char *)0;
}

XML_GetParsingStatus()

void XMLCALL XML_GetParsingStatus	(	XML_Parser	parser,
		XML_ParsingStatus *	status
	)

Definition at line 2231 of file xmlparse.c.

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

XML_GetSpecifiedAttributeCount()

int XMLCALL XML_GetSpecifiedAttributeCount

(

XML_Parser

parser

)

Definition at line 1561 of file xmlparse.c.

                                                  {
  if (parser == NULL)
    return -1;
  return parser->m_nSpecifiedAtts;
}

XML_MemFree()

void XMLCALL XML_MemFree	(	XML_Parser	parser,
		void *	ptr
	)

Definition at line 2329 of file xmlparse.c.

                                          {
  if (parser != NULL)
    FREE(parser, ptr);
}

XML_MemMalloc()

void *XMLCALL XML_MemMalloc	(	XML_Parser	parser,
		size_t	size
	)

Definition at line 2315 of file xmlparse.c.

                                              {
  if (parser == NULL)
    return NULL;
  return MALLOC(parser, size);
}

XML_MemRealloc()

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

Definition at line 2322 of file xmlparse.c.

                                                          {
  if (parser == NULL)
    return NULL;
  return REALLOC(parser, ptr, size);
}

XML_Parse()

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

Definition at line 1819 of file xmlparse.c.

                                                                  {
  if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
    if (parser != NULL)
      parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
    return XML_STATUS_ERROR;
  }
  switch (parser->m_parsingStatus.parsing) {
  case XML_SUSPENDED:
    parser->m_errorCode = XML_ERROR_SUSPENDED;
    return XML_STATUS_ERROR;
  case XML_FINISHED:
    parser->m_errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  case XML_INITIALIZED:
    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
      parser->m_errorCode = XML_ERROR_NO_MEMORY;
      return XML_STATUS_ERROR;
    }
    /* fall through */
  default:
    parser->m_parsingStatus.parsing = XML_PARSING;
  }
 
  if (len == 0) {
    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
    if (! isFinal)
      return XML_STATUS_OK;
    parser->m_positionPtr = parser->m_bufferPtr;
    parser->m_parseEndPtr = parser->m_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.
    */
    parser->m_errorCode
        = parser->m_processor(parser, parser->m_bufferPtr,
                              parser->m_parseEndPtr, &parser->m_bufferPtr);
 
    if (parser->m_errorCode == XML_ERROR_NONE) {
      switch (parser->m_parsingStatus.parsing) {
      case XML_SUSPENDED:
        /* It is hard to be certain, but it seems that this case
         * cannot occur.  This code is cleaning up a previous parse
         * with no new data (since len == 0).  Changing the parsing
         * state requires getting to execute a handler function, and
         * there doesn't seem to be an opportunity for that while in
         * this circumstance.
         *
         * Given the uncertainty, we retain the code but exclude it
         * from coverage tests.
         *
         * LCOV_EXCL_START
         */
        XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
                          parser->m_bufferPtr, &parser->m_position);
        parser->m_positionPtr = parser->m_bufferPtr;
        return XML_STATUS_SUSPENDED;
        /* LCOV_EXCL_STOP */
      case XML_INITIALIZED:
      case XML_PARSING:
        parser->m_parsingStatus.parsing = XML_FINISHED;
        /* fall through */
      default:
        return XML_STATUS_OK;
      }
    }
    parser->m_eventEndPtr = parser->m_eventPtr;
    parser->m_processor = errorProcessor;
    return XML_STATUS_ERROR;
  }
#ifndef XML_CONTEXT_BYTES
  else if (parser->m_bufferPtr == parser->m_bufferEnd) {
    const char *end;
    int nLeftOver;
    enum XML_Status result;
    /* Detect overflow (a+b > MAX <==> b > MAX-a) */
    if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
      parser->m_errorCode = XML_ERROR_NO_MEMORY;
      parser->m_eventPtr = parser->m_eventEndPtr = NULL;
      parser->m_processor = errorProcessor;
      return XML_STATUS_ERROR;
    }
    parser->m_parseEndByteIndex += len;
    parser->m_positionPtr = s;
    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
 
    parser->m_errorCode
        = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
 
    if (parser->m_errorCode != XML_ERROR_NONE) {
      parser->m_eventEndPtr = parser->m_eventPtr;
      parser->m_processor = errorProcessor;
      return XML_STATUS_ERROR;
    } else {
      switch (parser->m_parsingStatus.parsing) {
      case XML_SUSPENDED:
        result = XML_STATUS_SUSPENDED;
        break;
      case XML_INITIALIZED:
      case XML_PARSING:
        if (isFinal) {
          parser->m_parsingStatus.parsing = XML_FINISHED;
          return XML_STATUS_OK;
        }
      /* fall through */
      default:
        result = XML_STATUS_OK;
      }
    }
 
    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
                      &parser->m_position);
    nLeftOver = s + len - end;
    if (nLeftOver) {
      if (parser->m_buffer == NULL
          || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
        /* avoid _signed_ integer overflow */
        char *temp = NULL;
        const int bytesToAllocate = (int)((unsigned)len * 2U);
        if (bytesToAllocate > 0) {
          temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
        }
        if (temp == NULL) {
          parser->m_errorCode = XML_ERROR_NO_MEMORY;
          parser->m_eventPtr = parser->m_eventEndPtr = NULL;
          parser->m_processor = errorProcessor;
          return XML_STATUS_ERROR;
        }
        parser->m_buffer = temp;
        parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
      }
      memcpy(parser->m_buffer, end, nLeftOver);
    }
    parser->m_bufferPtr = parser->m_buffer;
    parser->m_bufferEnd = parser->m_buffer + nLeftOver;
    parser->m_positionPtr = parser->m_bufferPtr;
    parser->m_parseEndPtr = parser->m_bufferEnd;
    parser->m_eventPtr = parser->m_bufferPtr;
    parser->m_eventEndPtr = parser->m_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);
    }
  }
}

XML_ParseBuffer()

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

Definition at line 1973 of file xmlparse.c.

                                                         {
  const char *start;
  enum XML_Status result = XML_STATUS_OK;
 
  if (parser == NULL)
    return XML_STATUS_ERROR;
  switch (parser->m_parsingStatus.parsing) {
  case XML_SUSPENDED:
    parser->m_errorCode = XML_ERROR_SUSPENDED;
    return XML_STATUS_ERROR;
  case XML_FINISHED:
    parser->m_errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  case XML_INITIALIZED:
    /* Has someone called XML_GetBuffer successfully before? */
    if (! parser->m_bufferPtr) {
      parser->m_errorCode = XML_ERROR_NO_BUFFER;
      return XML_STATUS_ERROR;
    }
 
    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
      parser->m_errorCode = XML_ERROR_NO_MEMORY;
      return XML_STATUS_ERROR;
    }
    /* fall through */
  default:
    parser->m_parsingStatus.parsing = XML_PARSING;
  }
 
  start = parser->m_bufferPtr;
  parser->m_positionPtr = start;
  parser->m_bufferEnd += len;
  parser->m_parseEndPtr = parser->m_bufferEnd;
  parser->m_parseEndByteIndex += len;
  parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
 
  parser->m_errorCode = parser->m_processor(
      parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
 
  if (parser->m_errorCode != XML_ERROR_NONE) {
    parser->m_eventEndPtr = parser->m_eventPtr;
    parser->m_processor = errorProcessor;
    return XML_STATUS_ERROR;
  } else {
    switch (parser->m_parsingStatus.parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED:
    case XML_PARSING:
      if (isFinal) {
        parser->m_parsingStatus.parsing = XML_FINISHED;
        return result;
      }
    default:; /* should not happen */
    }
  }
 
  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
                    parser->m_bufferPtr, &parser->m_position);
  parser->m_positionPtr = parser->m_bufferPtr;
  return result;
}

Referenced by XML_Parse().

XML_ParserCreate()

XML_Parser XMLCALL XML_ParserCreate

(

const XML_Char *

encodingName

)

Definition at line 716 of file xmlparse.c.

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

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 965 of file xmlparse.c.

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

Referenced by XML_ParserCreate(), and XML_ParserCreateNS().

XML_ParserCreateNS()

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

Definition at line 721 of file xmlparse.c.

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

XML_ParserFree()

void XMLCALL XML_ParserFree

(

XML_Parser

parser

)

Definition at line 1430 of file xmlparse.c.

                                  {
  TAG *tagList;
  OPEN_INTERNAL_ENTITY *entityList;
  if (parser == NULL)
    return;
  /* free m_tagStack and m_freeTagList */
  tagList = parser->m_tagStack;
  for (;;) {
    TAG *p;
    if (tagList == NULL) {
      if (parser->m_freeTagList == NULL)
        break;
      tagList = parser->m_freeTagList;
      parser->m_freeTagList = NULL;
    }
    p = tagList;
    tagList = tagList->parent;
    FREE(parser, p->buf);
    destroyBindings(p->bindings, parser);
    FREE(parser, p);
  }
  /* free m_openInternalEntities and m_freeInternalEntities */
  entityList = parser->m_openInternalEntities;
  for (;;) {
    OPEN_INTERNAL_ENTITY *openEntity;
    if (entityList == NULL) {
      if (parser->m_freeInternalEntities == NULL)
        break;
      entityList = parser->m_freeInternalEntities;
      parser->m_freeInternalEntities = NULL;
    }
    openEntity = entityList;
    entityList = entityList->next;
    FREE(parser, openEntity);
  }
 
  destroyBindings(parser->m_freeBindingList, parser);
  destroyBindings(parser->m_inheritedBindings, parser);
  poolDestroy(&parser->m_tempPool);
  poolDestroy(&parser->m_temp2Pool);
  FREE(parser, (void *)parser->m_protocolEncodingName);
#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 (! parser->m_isParamEntity && parser->m_dtd)
#else
  if (parser->m_dtd)
#endif /* XML_DTD */
    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
               &parser->m_mem);
  FREE(parser, (void *)parser->m_atts);
#ifdef XML_ATTR_INFO
  FREE(parser, (void *)parser->m_attInfo);
#endif
  FREE(parser, parser->m_groupConnector);
  FREE(parser, parser->m_buffer);
  FREE(parser, parser->m_dataBuf);
  FREE(parser, parser->m_nsAtts);
  FREE(parser, parser->m_unknownEncodingMem);
  if (parser->m_unknownEncodingRelease)
    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
  FREE(parser, parser);
}

Referenced by XML_ExternalEntityParserCreate().

XML_ParserReset()

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

Definition at line 1182 of file xmlparse.c.

                                                                 {
  TAG *tStk;
  OPEN_INTERNAL_ENTITY *openEntityList;
 
  if (parser == NULL)
    return XML_FALSE;
 
  if (parser->m_parentParser)
    return XML_FALSE;
  /* move m_tagStack to m_freeTagList */
  tStk = parser->m_tagStack;
  while (tStk) {
    TAG *tag = tStk;
    tStk = tStk->parent;
    tag->parent = parser->m_freeTagList;
    moveToFreeBindingList(parser, tag->bindings);
    tag->bindings = NULL;
    parser->m_freeTagList = tag;
  }
  /* move m_openInternalEntities to m_freeInternalEntities */
  openEntityList = parser->m_openInternalEntities;
  while (openEntityList) {
    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
    openEntityList = openEntity->next;
    openEntity->next = parser->m_freeInternalEntities;
    parser->m_freeInternalEntities = openEntity;
  }
  moveToFreeBindingList(parser, parser->m_inheritedBindings);
  FREE(parser, parser->m_unknownEncodingMem);
  if (parser->m_unknownEncodingRelease)
    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
  poolClear(&parser->m_tempPool);
  poolClear(&parser->m_temp2Pool);
  FREE(parser, (void *)parser->m_protocolEncodingName);
  parser->m_protocolEncodingName = NULL;
  parserInit(parser, encodingName);
  dtdReset(parser->m_dtd, &parser->m_mem);
  return XML_TRUE;
}

XML_ResumeParser()

enum XML_Status XMLCALL XML_ResumeParser

(

XML_Parser

parser

)

Definition at line 2191 of file xmlparse.c.

                                    {
  enum XML_Status result = XML_STATUS_OK;
 
  if (parser == NULL)
    return XML_STATUS_ERROR;
  if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
    parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
    return XML_STATUS_ERROR;
  }
  parser->m_parsingStatus.parsing = XML_PARSING;
 
  parser->m_errorCode = parser->m_processor(
      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
 
  if (parser->m_errorCode != XML_ERROR_NONE) {
    parser->m_eventEndPtr = parser->m_eventPtr;
    parser->m_processor = errorProcessor;
    return XML_STATUS_ERROR;
  } else {
    switch (parser->m_parsingStatus.parsing) {
    case XML_SUSPENDED:
      result = XML_STATUS_SUSPENDED;
      break;
    case XML_INITIALIZED:
    case XML_PARSING:
      if (parser->m_parsingStatus.finalBuffer) {
        parser->m_parsingStatus.parsing = XML_FINISHED;
        return result;
      }
    default:;
    }
  }
 
  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
                    parser->m_bufferPtr, &parser->m_position);
  parser->m_positionPtr = parser->m_bufferPtr;
  return result;
}

XML_SetAttlistDeclHandler()

void XMLCALL XML_SetAttlistDeclHandler	(	XML_Parser	parser,
		XML_AttlistDeclHandler	attdecl
	)

Definition at line 1770 of file xmlparse.c.

                                                                             {
  if (parser != NULL)
    parser->m_attlistDeclHandler = attdecl;
}

XML_SetBase()

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

Definition at line 1540 of file xmlparse.c.

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

XML_SetCdataSectionHandler()

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

Definition at line 1625 of file xmlparse.c.

                                                           {
  if (parser == NULL)
    return;
  parser->m_startCdataSectionHandler = start;
  parser->m_endCdataSectionHandler = end;
}

XML_SetCharacterDataHandler()

void XMLCALL XML_SetCharacterDataHandler	(	XML_Parser	parser,
		XML_CharacterDataHandler	handler
	)

Definition at line 1605 of file xmlparse.c.

                                                              {
  if (parser != NULL)
    parser->m_characterDataHandler = handler;
}

XML_SetCommentHandler()

void XMLCALL XML_SetCommentHandler	(	XML_Parser	parser,
		XML_CommentHandler	handler
	)

Definition at line 1619 of file xmlparse.c.

                                                                     {
  if (parser != NULL)
    parser->m_commentHandler = handler;
}

XML_SetDefaultHandler()

void XMLCALL XML_SetDefaultHandler	(	XML_Parser	parser,
		XML_DefaultHandler	handler
	)

Definition at line 1649 of file xmlparse.c.

                                                                     {
  if (parser == NULL)
    return;
  parser->m_defaultHandler = handler;
  parser->m_defaultExpandInternalEntities = XML_FALSE;
}

XML_SetDefaultHandlerExpand()

void XMLCALL XML_SetDefaultHandlerExpand	(	XML_Parser	parser,
		XML_DefaultHandler	handler
	)

Definition at line 1657 of file xmlparse.c.

                                                                           {
  if (parser == NULL)
    return;
  parser->m_defaultHandler = handler;
  parser->m_defaultExpandInternalEntities = XML_TRUE;
}

XML_SetDoctypeDeclHandler()

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

Definition at line 1665 of file xmlparse.c.

                                                         {
  if (parser == NULL)
    return;
  parser->m_startDoctypeDeclHandler = start;
  parser->m_endDoctypeDeclHandler = end;
}

XML_SetElementDeclHandler()

void XMLCALL XML_SetElementDeclHandler	(	XML_Parser	parser,
		XML_ElementDeclHandler	eldecl
	)

Definition at line 1764 of file xmlparse.c.

                                                                            {
  if (parser != NULL)
    parser->m_elementDeclHandler = eldecl;
}

XML_SetElementHandler()

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

Definition at line 1584 of file xmlparse.c.

                                                 {
  if (parser == NULL)
    return;
  parser->m_startElementHandler = start;
  parser->m_endElementHandler = end;
}

XML_SetEncoding()

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

Definition at line 1223 of file xmlparse.c.

                                                                 {
  if (parser == NULL)
    return XML_STATUS_ERROR;
  /* 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 (parser->m_parsingStatus.parsing == XML_PARSING
      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
    return XML_STATUS_ERROR;
 
  /* Get rid of any previous encoding name */
  FREE(parser, (void *)parser->m_protocolEncodingName);
 
  if (encodingName == NULL)
    /* No new encoding name */
    parser->m_protocolEncodingName = NULL;
  else {
    /* Copy the new encoding name into allocated memory */
    parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
    if (! parser->m_protocolEncodingName)
      return XML_STATUS_ERROR;
  }
  return XML_STATUS_OK;
}

XML_SetEndCdataSectionHandler()

void XMLCALL XML_SetEndCdataSectionHandler	(	XML_Parser	parser,
		XML_EndCdataSectionHandler	end
	)

Definition at line 1642 of file xmlparse.c.

                                                              {
  if (parser != NULL)
    parser->m_endCdataSectionHandler = end;
}

XML_SetEndDoctypeDeclHandler()

void XMLCALL XML_SetEndDoctypeDeclHandler	(	XML_Parser	parser,
		XML_EndDoctypeDeclHandler	end
	)

Definition at line 1681 of file xmlparse.c.

                                                                               {
  if (parser != NULL)
    parser->m_endDoctypeDeclHandler = end;
}

XML_SetEndElementHandler()

void XMLCALL XML_SetEndElementHandler	(	XML_Parser	parser,
		XML_EndElementHandler	end
	)

Definition at line 1599 of file xmlparse.c.

                                                                       {
  if (parser != NULL)
    parser->m_endElementHandler = end;
}

XML_SetEndNamespaceDeclHandler()

void XMLCALL XML_SetEndNamespaceDeclHandler	(	XML_Parser	parser,
		XML_EndNamespaceDeclHandler	end
	)

Definition at line 1717 of file xmlparse.c.

                                                                {
  if (parser != NULL)
    parser->m_endNamespaceDeclHandler = end;
}

XML_SetEntityDeclHandler()

void XMLCALL XML_SetEntityDeclHandler	(	XML_Parser	parser,
		XML_EntityDeclHandler	handler
	)

Definition at line 1776 of file xmlparse.c.

                                                                           {
  if (parser != NULL)
    parser->m_entityDeclHandler = handler;
}

XML_SetExternalEntityRefHandler()

void XMLCALL XML_SetExternalEntityRefHandler	(	XML_Parser	parser,
		XML_ExternalEntityRefHandler	handler
	)

Definition at line 1731 of file xmlparse.c.

                                                                      {
  if (parser != NULL)
    parser->m_externalEntityRefHandler = handler;
}

XML_SetExternalEntityRefHandlerArg()

void XMLCALL XML_SetExternalEntityRefHandlerArg	(	XML_Parser	parser,
		void *	arg
	)

Definition at line 1738 of file xmlparse.c.

                                                                 {
  if (parser == NULL)
    return;
  if (arg)
    parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
  else
    parser->m_externalEntityRefHandlerArg = parser;
}

XML_SetHashSalt()

int XMLCALL XML_SetHashSalt	(	XML_Parser	parser,
		unsigned long	hash_salt
	)

Definition at line 1805 of file xmlparse.c.

                                                            {
  if (parser == NULL)
    return 0;
  if (parser->m_parentParser)
    return XML_SetHashSalt(parser->m_parentParser, hash_salt);
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (parser->m_parsingStatus.parsing == XML_PARSING
      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
    return 0;
  parser->m_hash_secret_salt = hash_salt;
  return 1;
}

Referenced by XML_SetHashSalt().

XML_SetNamespaceDeclHandler()

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

Definition at line 1700 of file xmlparse.c.

                                                             {
  if (parser == NULL)
    return;
  parser->m_startNamespaceDeclHandler = start;
  parser->m_endNamespaceDeclHandler = end;
}

XML_SetNotationDeclHandler()

void XMLCALL XML_SetNotationDeclHandler	(	XML_Parser	parser,
		XML_NotationDeclHandler	handler
	)

Definition at line 1694 of file xmlparse.c.

                                                                               {
  if (parser != NULL)
    parser->m_notationDeclHandler = handler;
}

XML_SetNotStandaloneHandler()

void XMLCALL XML_SetNotStandaloneHandler	(	XML_Parser	parser,
		XML_NotStandaloneHandler	handler
	)

Definition at line 1724 of file xmlparse.c.

                                                              {
  if (parser != NULL)
    parser->m_notStandaloneHandler = handler;
}

XML_SetParamEntityParsing()

int XMLCALL XML_SetParamEntityParsing	(	XML_Parser	parser,
		enum XML_ParamEntityParsing	peParsing
	)

Definition at line 1788 of file xmlparse.c.

                                                                 {
  if (parser == NULL)
    return 0;
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (parser->m_parsingStatus.parsing == XML_PARSING
      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
    return 0;
#ifdef XML_DTD
  parser->m_paramEntityParsing = peParsing;
  return 1;
#else
  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
#endif
}

XML_SetProcessingInstructionHandler()

void XMLCALL XML_SetProcessingInstructionHandler	(	XML_Parser	parser,
		XML_ProcessingInstructionHandler	handler
	)

Definition at line 1612 of file xmlparse.c.

                                                                              {
  if (parser != NULL)
    parser->m_processingInstructionHandler = handler;
}

XML_SetReturnNSTriplet()

void XMLCALL XML_SetReturnNSTriplet	(	XML_Parser	parser,
		int	do_nst
	)

Definition at line 1519 of file xmlparse.c.

                                                      {
  if (parser == NULL)
    return;
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (parser->m_parsingStatus.parsing == XML_PARSING
      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
    return;
  parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
}

XML_SetSkippedEntityHandler()

void XMLCALL XML_SetSkippedEntityHandler	(	XML_Parser	parser,
		XML_SkippedEntityHandler	handler
	)

Definition at line 1748 of file xmlparse.c.

                                                              {
  if (parser != NULL)
    parser->m_skippedEntityHandler = handler;
}

XML_SetStartCdataSectionHandler()

void XMLCALL XML_SetStartCdataSectionHandler	(	XML_Parser	parser,
		XML_StartCdataSectionHandler	start
	)

Definition at line 1635 of file xmlparse.c.

                                                                    {
  if (parser != NULL)
    parser->m_startCdataSectionHandler = start;
}

XML_SetStartDoctypeDeclHandler()

void XMLCALL XML_SetStartDoctypeDeclHandler	(	XML_Parser	parser,
		XML_StartDoctypeDeclHandler	start
	)

Definition at line 1674 of file xmlparse.c.

                                                                  {
  if (parser != NULL)
    parser->m_startDoctypeDeclHandler = start;
}

XML_SetStartElementHandler()

void XMLCALL XML_SetStartElementHandler	(	XML_Parser	parser,
		XML_StartElementHandler	start
	)

Definition at line 1593 of file xmlparse.c.

                                                                             {
  if (parser != NULL)
    parser->m_startElementHandler = start;
}

XML_SetStartNamespaceDeclHandler()

void XMLCALL XML_SetStartNamespaceDeclHandler	(	XML_Parser	parser,
		XML_StartNamespaceDeclHandler	start
	)

Definition at line 1710 of file xmlparse.c.

                                                                      {
  if (parser != NULL)
    parser->m_startNamespaceDeclHandler = start;
}

XML_SetUnknownEncodingHandler()

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

Definition at line 1755 of file xmlparse.c.

                                                                              {
  if (parser == NULL)
    return;
  parser->m_unknownEncodingHandler = handler;
  parser->m_unknownEncodingHandlerData = data;
}

XML_SetUnparsedEntityDeclHandler()

void XMLCALL XML_SetUnparsedEntityDeclHandler	(	XML_Parser	parser,
		XML_UnparsedEntityDeclHandler	handler
	)

Definition at line 1687 of file xmlparse.c.

                                                                        {
  if (parser != NULL)
    parser->m_unparsedEntityDeclHandler = handler;
}

XML_SetUserData()

void XMLCALL XML_SetUserData	(	XML_Parser	parser,
		void *	p
	)

Definition at line 1530 of file xmlparse.c.

                                            {
  if (parser == NULL)
    return;
  if (parser->m_handlerArg == parser->m_userData)
    parser->m_handlerArg = parser->m_userData = p;
  else
    parser->m_userData = p;
}

XML_SetXmlDeclHandler()

void XMLCALL XML_SetXmlDeclHandler	(	XML_Parser	parser,
		XML_XmlDeclHandler	handler
	)

Definition at line 1782 of file xmlparse.c.

                                                                     {
  if (parser != NULL)
    parser->m_xmlDeclHandler = handler;
}

XML_StopParser()

enum XML_Status XMLCALL XML_StopParser	(	XML_Parser	parser,
		XML_Bool	resumable
	)

Definition at line 2161 of file xmlparse.c.

                                                      {
  if (parser == NULL)
    return XML_STATUS_ERROR;
  switch (parser->m_parsingStatus.parsing) {
  case XML_SUSPENDED:
    if (resumable) {
      parser->m_errorCode = XML_ERROR_SUSPENDED;
      return XML_STATUS_ERROR;
    }
    parser->m_parsingStatus.parsing = XML_FINISHED;
    break;
  case XML_FINISHED:
    parser->m_errorCode = XML_ERROR_FINISHED;
    return XML_STATUS_ERROR;
  default:
    if (resumable) {
#ifdef XML_DTD
      if (parser->m_isParamEntity) {
        parser->m_errorCode = XML_ERROR_SUSPEND_PE;
        return XML_STATUS_ERROR;
      }
#endif
      parser->m_parsingStatus.parsing = XML_SUSPENDED;
    } else
      parser->m_parsingStatus.parsing = XML_FINISHED;
  }
  return XML_STATUS_OK;
}

XML_UseForeignDTD()

enum XML_Error XMLCALL XML_UseForeignDTD	(	XML_Parser	parser,
		XML_Bool	useDTD
	)

Definition at line 1502 of file xmlparse.c.

                                                      {
  if (parser == NULL)
    return XML_ERROR_INVALID_ARGUMENT;
#ifdef XML_DTD
  /* block after XML_Parse()/XML_ParseBuffer() has been called */
  if (parser->m_parsingStatus.parsing == XML_PARSING
      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
  parser->m_useForeignDTD = useDTD;
  return XML_ERROR_NONE;
#else
  UNUSED_P(useDTD);
  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
#endif
}

XML_UseParserAsHandlerArg()

void XMLCALL XML_UseParserAsHandlerArg

(

XML_Parser

parser

)

Definition at line 1496 of file xmlparse.c.

                                             {
  if (parser != NULL)
    parser->m_handlerArg = parser;
}