expat.h File Reference

#include <stdlib.h>
#include "expat_external.h"

Go to the source code of this file.

Classes
struct	XML_cp
struct	XML_Memory_Handling_Suite
struct	XML_Encoding
struct	XML_ParsingStatus
struct	XML_Expat_Version
struct	XML_Feature

Macros
#define	XML_TRUE   ((XML_Bool)1)
#define	XML_FALSE   ((XML_Bool)0)
#define	XML_STATUS_ERROR   XML_STATUS_ERROR
#define	XML_STATUS_OK   XML_STATUS_OK
#define	XML_STATUS_SUSPENDED   XML_STATUS_SUSPENDED
#define	XML_GetUserData(parser)   (*(void **)(parser))
#define	XML_GetErrorLineNumber   XML_GetCurrentLineNumber
#define	XML_GetErrorColumnNumber   XML_GetCurrentColumnNumber
#define	XML_GetErrorByteIndex   XML_GetCurrentByteIndex
#define	XML_MAJOR_VERSION   2
#define	XML_MINOR_VERSION   4
#define	XML_MICRO_VERSION   9

Typedefs
typedef struct XML_ParserStruct *	XML_Parser
typedef unsigned char	XML_Bool
typedef struct XML_cp	XML_Content
typedef void(XMLCALL *	XML_ElementDeclHandler) (void *userData, const XML_Char *name, XML_Content *model)
typedef void(XMLCALL *	XML_AttlistDeclHandler) (void *userData, const XML_Char *elname, const XML_Char *attname, const XML_Char *att_type, const XML_Char *dflt, int isrequired)
typedef void(XMLCALL *	XML_XmlDeclHandler) (void *userData, const XML_Char *version, const XML_Char *encoding, int standalone)
typedef void(XMLCALL *	XML_StartElementHandler) (void *userData, const XML_Char *name, const XML_Char **atts)
typedef void(XMLCALL *	XML_EndElementHandler) (void *userData, const XML_Char *name)
typedef void(XMLCALL *	XML_CharacterDataHandler) (void *userData, const XML_Char *s, int len)
typedef void(XMLCALL *	XML_ProcessingInstructionHandler) (void *userData, const XML_Char *target, const XML_Char *data)
typedef void(XMLCALL *	XML_CommentHandler) (void *userData, const XML_Char *data)
typedef void(XMLCALL *	XML_StartCdataSectionHandler) (void *userData)
typedef void(XMLCALL *	XML_EndCdataSectionHandler) (void *userData)
typedef void(XMLCALL *	XML_DefaultHandler) (void *userData, const XML_Char *s, int len)
typedef void(XMLCALL *	XML_StartDoctypeDeclHandler) (void *userData, const XML_Char *doctypeName, const XML_Char *sysid, const XML_Char *pubid, int has_internal_subset)
typedef void(XMLCALL *	XML_EndDoctypeDeclHandler) (void *userData)
typedef void(XMLCALL *	XML_EntityDeclHandler) (void *userData, const XML_Char *entityName, int is_parameter_entity, const XML_Char *value, int value_length, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)
typedef void(XMLCALL *	XML_UnparsedEntityDeclHandler) (void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)
typedef void(XMLCALL *	XML_NotationDeclHandler) (void *userData, const XML_Char *notationName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
typedef void(XMLCALL *	XML_StartNamespaceDeclHandler) (void *userData, const XML_Char *prefix, const XML_Char *uri)
typedef void(XMLCALL *	XML_EndNamespaceDeclHandler) (void *userData, const XML_Char *prefix)
typedef int(XMLCALL *	XML_NotStandaloneHandler) (void *userData)
typedef int(XMLCALL *	XML_ExternalEntityRefHandler) (XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)
typedef void(XMLCALL *	XML_SkippedEntityHandler) (void *userData, const XML_Char *entityName, int is_parameter_entity)
typedef int(XMLCALL *	XML_UnknownEncodingHandler) (void *encodingHandlerData, const XML_Char *name, XML_Encoding *info)

Enumerations
enum	XML_Status {   XML_STATUS_ERROR = 0 , XML_STATUS_ERROR = 0 , XML_STATUS_OK = 1 , XML_STATUS_OK = 1 ,   XML_STATUS_SUSPENDED }
enum	XML_Error {   XML_ERROR_NONE , XML_ERROR_NO_MEMORY , XML_ERROR_SYNTAX , XML_ERROR_NO_ELEMENTS ,   XML_ERROR_INVALID_TOKEN , XML_ERROR_UNCLOSED_TOKEN , XML_ERROR_PARTIAL_CHAR , XML_ERROR_TAG_MISMATCH ,   XML_ERROR_DUPLICATE_ATTRIBUTE , XML_ERROR_JUNK_AFTER_DOC_ELEMENT , XML_ERROR_PARAM_ENTITY_REF , XML_ERROR_UNDEFINED_ENTITY ,   XML_ERROR_RECURSIVE_ENTITY_REF , XML_ERROR_ASYNC_ENTITY , XML_ERROR_BAD_CHAR_REF , XML_ERROR_BINARY_ENTITY_REF ,   XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF , XML_ERROR_MISPLACED_XML_PI , XML_ERROR_UNKNOWN_ENCODING , XML_ERROR_INCORRECT_ENCODING ,   XML_ERROR_UNCLOSED_CDATA_SECTION , XML_ERROR_EXTERNAL_ENTITY_HANDLING , XML_ERROR_NOT_STANDALONE , XML_ERROR_UNEXPECTED_STATE ,   XML_ERROR_ENTITY_DECLARED_IN_PE , XML_ERROR_FEATURE_REQUIRES_XML_DTD , XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING , XML_ERROR_UNBOUND_PREFIX ,   XML_ERROR_UNDECLARING_PREFIX , XML_ERROR_INCOMPLETE_PE , XML_ERROR_XML_DECL , XML_ERROR_TEXT_DECL ,   XML_ERROR_PUBLICID , XML_ERROR_SUSPENDED , XML_ERROR_NOT_SUSPENDED , XML_ERROR_ABORTED ,   XML_ERROR_FINISHED , XML_ERROR_SUSPEND_PE , XML_ERROR_RESERVED_PREFIX_XML , XML_ERROR_RESERVED_PREFIX_XMLNS ,   XML_ERROR_RESERVED_NAMESPACE_URI , XML_ERROR_INVALID_ARGUMENT , XML_ERROR_NO_BUFFER , XML_ERROR_AMPLIFICATION_LIMIT_BREACH }
enum	XML_Content_Type {   XML_CTYPE_EMPTY = 1 , XML_CTYPE_ANY , XML_CTYPE_MIXED , XML_CTYPE_NAME ,   XML_CTYPE_CHOICE , XML_CTYPE_SEQ }
enum	XML_Content_Quant { XML_CQUANT_NONE , XML_CQUANT_OPT , XML_CQUANT_REP , XML_CQUANT_PLUS }
enum	XML_Parsing { XML_INITIALIZED , XML_PARSING , XML_FINISHED , XML_SUSPENDED }
enum	XML_ParamEntityParsing { XML_PARAM_ENTITY_PARSING_NEVER , XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE , XML_PARAM_ENTITY_PARSING_ALWAYS }
enum	XML_FeatureEnum {   XML_FEATURE_END = 0 , XML_FEATURE_UNICODE , XML_FEATURE_UNICODE_WCHAR_T , XML_FEATURE_DTD ,   XML_FEATURE_CONTEXT_BYTES , XML_FEATURE_MIN_SIZE , XML_FEATURE_SIZEOF_XML_CHAR , XML_FEATURE_SIZEOF_XML_LCHAR ,   XML_FEATURE_NS , XML_FEATURE_LARGE_SIZE , XML_FEATURE_ATTR_INFO , XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT ,   XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT }

Functions
	XML_SetElementDeclHandler (XML_Parser parser, XML_ElementDeclHandler eldecl)
	XML_SetAttlistDeclHandler (XML_Parser parser, XML_AttlistDeclHandler attdecl)
	XML_SetXmlDeclHandler (XML_Parser parser, XML_XmlDeclHandler xmldecl)
	XML_ParserCreate (const XML_Char *encoding)
	XML_ParserCreateNS (const XML_Char *encoding, XML_Char namespaceSeparator)
	XML_ParserCreate_MM (const XML_Char *encoding, const XML_Memory_Handling_Suite *memsuite, const XML_Char *namespaceSeparator)
	XML_ParserReset (XML_Parser parser, const XML_Char *encoding)
	XML_SetEntityDeclHandler (XML_Parser parser, XML_EntityDeclHandler handler)
	XML_SetElementHandler (XML_Parser parser, XML_StartElementHandler start, XML_EndElementHandler end)
	XML_SetStartElementHandler (XML_Parser parser, XML_StartElementHandler handler)
	XML_SetEndElementHandler (XML_Parser parser, XML_EndElementHandler handler)
	XML_SetCharacterDataHandler (XML_Parser parser, XML_CharacterDataHandler handler)
	XML_SetProcessingInstructionHandler (XML_Parser parser, XML_ProcessingInstructionHandler handler)
	XML_SetCommentHandler (XML_Parser parser, XML_CommentHandler handler)
	XML_SetCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start, XML_EndCdataSectionHandler end)
	XML_SetStartCdataSectionHandler (XML_Parser parser, XML_StartCdataSectionHandler start)
	XML_SetEndCdataSectionHandler (XML_Parser parser, XML_EndCdataSectionHandler end)
	XML_SetDefaultHandler (XML_Parser parser, XML_DefaultHandler handler)
	XML_SetDefaultHandlerExpand (XML_Parser parser, XML_DefaultHandler handler)
	XML_SetDoctypeDeclHandler (XML_Parser parser, XML_StartDoctypeDeclHandler start, XML_EndDoctypeDeclHandler end)
	XML_SetStartDoctypeDeclHandler (XML_Parser parser, XML_StartDoctypeDeclHandler start)
	XML_SetEndDoctypeDeclHandler (XML_Parser parser, XML_EndDoctypeDeclHandler end)
	XML_SetUnparsedEntityDeclHandler (XML_Parser parser, XML_UnparsedEntityDeclHandler handler)
	XML_SetNotationDeclHandler (XML_Parser parser, XML_NotationDeclHandler handler)
	XML_SetNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start, XML_EndNamespaceDeclHandler end)
	XML_SetStartNamespaceDeclHandler (XML_Parser parser, XML_StartNamespaceDeclHandler start)
	XML_SetEndNamespaceDeclHandler (XML_Parser parser, XML_EndNamespaceDeclHandler end)
	XML_SetNotStandaloneHandler (XML_Parser parser, XML_NotStandaloneHandler handler)
	XML_SetExternalEntityRefHandler (XML_Parser parser, XML_ExternalEntityRefHandler handler)
	XML_SetExternalEntityRefHandlerArg (XML_Parser parser, void *arg)
	XML_SetSkippedEntityHandler (XML_Parser parser, XML_SkippedEntityHandler handler)
	XML_SetUnknownEncodingHandler (XML_Parser parser, XML_UnknownEncodingHandler handler, void *encodingHandlerData)
	XML_DefaultCurrent (XML_Parser parser)
	XML_SetReturnNSTriplet (XML_Parser parser, int do_nst)
	XML_SetUserData (XML_Parser parser, void *userData)
	XML_SetEncoding (XML_Parser parser, const XML_Char *encoding)
	XML_UseParserAsHandlerArg (XML_Parser parser)
	XML_UseForeignDTD (XML_Parser parser, XML_Bool useDTD)
	XML_SetBase (XML_Parser parser, const XML_Char *base)
	XML_GetBase (XML_Parser parser)
	XML_GetSpecifiedAttributeCount (XML_Parser parser)
	XML_GetIdAttributeIndex (XML_Parser parser)
	XML_Parse (XML_Parser parser, const char *s, int len, int isFinal)
	XML_GetBuffer (XML_Parser parser, int len)
	XML_ParseBuffer (XML_Parser parser, int len, int isFinal)
	XML_StopParser (XML_Parser parser, XML_Bool resumable)
	XML_ResumeParser (XML_Parser parser)
	XML_GetParsingStatus (XML_Parser parser, XML_ParsingStatus *status)
	XML_ExternalEntityParserCreate (XML_Parser parser, const XML_Char *context, const XML_Char *encoding)
	XML_SetParamEntityParsing (XML_Parser parser, enum XML_ParamEntityParsing parsing)
	XML_SetHashSalt (XML_Parser parser, unsigned long hash_salt)
	XML_GetErrorCode (XML_Parser parser)
	XMLPARSEAPI (XML_Size) XML_GetCurrentLineNumber(XML_Parser parser)
	XMLPARSEAPI (XML_Index) XML_GetCurrentByteIndex(XML_Parser parser)
	XML_GetCurrentByteCount (XML_Parser parser)
	XML_GetInputContext (XML_Parser parser, int *offset, int *size)
	XML_FreeContentModel (XML_Parser parser, XML_Content *model)
XML_ATTR_MALLOC	XML_MemMalloc (XML_Parser parser, size_t size)
	XML_MemRealloc (XML_Parser parser, void *ptr, size_t size)
	XML_MemFree (XML_Parser parser, void *ptr)
	XML_ParserFree (XML_Parser parser)
	XML_ErrorString (enum XML_Error code)
	XML_ExpatVersion (void)
	XML_ExpatVersionInfo (void)
	XML_GetFeatureList (void)

Macro Definition Documentation

XML_FALSE

#define XML_FALSE   ((XML_Bool)0)

Definition at line 56 of file expat.h.

XML_GetErrorByteIndex

#define XML_GetErrorByteIndex   XML_GetCurrentByteIndex

Definition at line 970 of file expat.h.

XML_GetErrorColumnNumber

#define XML_GetErrorColumnNumber   XML_GetCurrentColumnNumber

Definition at line 969 of file expat.h.

XML_GetErrorLineNumber

#define XML_GetErrorLineNumber   XML_GetCurrentLineNumber

Definition at line 968 of file expat.h.

XML_GetUserData

#define XML_GetUserData

(

parser

)

(*(void **)(parser))

Definition at line 678 of file expat.h.

XML_MAJOR_VERSION

#define XML_MAJOR_VERSION   2

Definition at line 1056 of file expat.h.

XML_MICRO_VERSION

#define XML_MICRO_VERSION   9

Definition at line 1058 of file expat.h.

XML_MINOR_VERSION

#define XML_MINOR_VERSION   4

Definition at line 1057 of file expat.h.

XML_STATUS_ERROR

#define XML_STATUS_ERROR   XML_STATUS_ERROR

Definition at line 73 of file expat.h.

XML_STATUS_OK

#define XML_STATUS_OK   XML_STATUS_OK

Definition at line 75 of file expat.h.

XML_STATUS_SUSPENDED

#define XML_STATUS_SUSPENDED   XML_STATUS_SUSPENDED

XML_TRUE

#define XML_TRUE   ((XML_Bool)1)

Definition at line 55 of file expat.h.

Typedef Documentation

XML_AttlistDeclHandler

typedef void(XMLCALL * XML_AttlistDeclHandler) (void *userData, const XML_Char *elname, const XML_Char *attname, const XML_Char *att_type, const XML_Char *dflt, int isrequired)

Definition at line 198 of file expat.h.

XML_Bool

typedef unsigned char XML_Bool

Definition at line 54 of file expat.h.

XML_CharacterDataHandler

typedef void(XMLCALL * XML_CharacterDataHandler) (void *userData, const XML_Char *s, int len)

Definition at line 295 of file expat.h.

XML_CommentHandler

typedef void(XMLCALL * XML_CommentHandler) (void *userData, const XML_Char *data)

Definition at line 304 of file expat.h.

XML_Content

typedef struct XML_cp XML_Content

Definition at line 167 of file expat.h.

XML_DefaultHandler

typedef void(XMLCALL * XML_DefaultHandler) (void *userData, const XML_Char *s, int len)

Definition at line 322 of file expat.h.

XML_ElementDeclHandler

typedef void(XMLCALL * XML_ElementDeclHandler) (void *userData, const XML_Char *name, XML_Content *model)

Definition at line 183 of file expat.h.

XML_EndCdataSectionHandler

typedef void(XMLCALL * XML_EndCdataSectionHandler) (void *userData)

Definition at line 307 of file expat.h.

XML_EndDoctypeDeclHandler

typedef void(XMLCALL * XML_EndDoctypeDeclHandler) (void *userData)

Definition at line 338 of file expat.h.

XML_EndElementHandler

typedef void(XMLCALL * XML_EndElementHandler) (void *userData, const XML_Char *name)

Definition at line 291 of file expat.h.

XML_EndNamespaceDeclHandler

typedef void(XMLCALL * XML_EndNamespaceDeclHandler) (void *userData, const XML_Char *prefix)

Definition at line 401 of file expat.h.

XML_EntityDeclHandler

typedef void(XMLCALL * XML_EntityDeclHandler) (void *userData, const XML_Char *entityName, int is_parameter_entity, const XML_Char *value, int value_length, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)

Definition at line 358 of file expat.h.

XML_ExternalEntityRefHandler

typedef int(XMLCALL * XML_ExternalEntityRefHandler) (XML_Parser parser, const XML_Char *context, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)

Definition at line 449 of file expat.h.

XML_NotationDeclHandler

typedef void(XMLCALL * XML_NotationDeclHandler) (void *userData, const XML_Char *notationName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId)

Definition at line 385 of file expat.h.

XML_NotStandaloneHandler

typedef int(XMLCALL * XML_NotStandaloneHandler) (void *userData)

Definition at line 413 of file expat.h.

XML_Parser

typedef struct XML_ParserStruct* XML_Parser

Definition at line 52 of file expat.h.

XML_ProcessingInstructionHandler

typedef void(XMLCALL * XML_ProcessingInstructionHandler) (void *userData, const XML_Char *target, const XML_Char *data)

Definition at line 299 of file expat.h.

XML_SkippedEntityHandler

typedef void(XMLCALL * XML_SkippedEntityHandler) (void *userData, const XML_Char *entityName, int is_parameter_entity)

Definition at line 465 of file expat.h.

XML_StartCdataSectionHandler

typedef void(XMLCALL * XML_StartCdataSectionHandler) (void *userData)

Definition at line 306 of file expat.h.

XML_StartDoctypeDeclHandler

typedef void(XMLCALL * XML_StartDoctypeDeclHandler) (void *userData, const XML_Char *doctypeName, const XML_Char *sysid, const XML_Char *pubid, int has_internal_subset)

Definition at line 328 of file expat.h.

XML_StartElementHandler

typedef void(XMLCALL * XML_StartElementHandler) (void *userData, const XML_Char *name, const XML_Char **atts)

Definition at line 287 of file expat.h.

XML_StartNamespaceDeclHandler

typedef void(XMLCALL * XML_StartNamespaceDeclHandler) (void *userData, const XML_Char *prefix, const XML_Char *uri)

Definition at line 397 of file expat.h.

XML_UnknownEncodingHandler

typedef int(XMLCALL * XML_UnknownEncodingHandler) (void *encodingHandlerData, const XML_Char *name, XML_Encoding *info)

Definition at line 543 of file expat.h.

XML_UnparsedEntityDeclHandler

typedef void(XMLCALL * XML_UnparsedEntityDeclHandler) (void *userData, const XML_Char *entityName, const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)

Definition at line 376 of file expat.h.

XML_XmlDeclHandler

typedef void(XMLCALL * XML_XmlDeclHandler) (void *userData, const XML_Char *version, const XML_Char *encoding, int standalone)

Definition at line 213 of file expat.h.

Enumeration Type Documentation

XML_Content_Quant

enum XML_Content_Quant

Enumerator
XML_CQUANT_NONE
XML_CQUANT_OPT
XML_CQUANT_REP
XML_CQUANT_PLUS

Definition at line 142 of file expat.h.

                       {
  XML_CQUANT_NONE,
  XML_CQUANT_OPT,
  XML_CQUANT_REP,
  XML_CQUANT_PLUS
};

XML_Content_Type

enum XML_Content_Type

Enumerator
XML_CTYPE_EMPTY
XML_CTYPE_ANY
XML_CTYPE_MIXED
XML_CTYPE_NAME
XML_CTYPE_CHOICE
XML_CTYPE_SEQ

Definition at line 133 of file expat.h.

                      {
  XML_CTYPE_EMPTY = 1,
  XML_CTYPE_ANY,
  XML_CTYPE_MIXED,
  XML_CTYPE_NAME,
  XML_CTYPE_CHOICE,
  XML_CTYPE_SEQ
};

XML_Error

enum XML_Error

Enumerator
XML_ERROR_NONE
XML_ERROR_NO_MEMORY
XML_ERROR_SYNTAX
XML_ERROR_NO_ELEMENTS
XML_ERROR_INVALID_TOKEN
XML_ERROR_UNCLOSED_TOKEN
XML_ERROR_PARTIAL_CHAR
XML_ERROR_TAG_MISMATCH
XML_ERROR_DUPLICATE_ATTRIBUTE
XML_ERROR_JUNK_AFTER_DOC_ELEMENT
XML_ERROR_PARAM_ENTITY_REF
XML_ERROR_UNDEFINED_ENTITY
XML_ERROR_RECURSIVE_ENTITY_REF
XML_ERROR_ASYNC_ENTITY
XML_ERROR_BAD_CHAR_REF
XML_ERROR_BINARY_ENTITY_REF
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF
XML_ERROR_MISPLACED_XML_PI
XML_ERROR_UNKNOWN_ENCODING
XML_ERROR_INCORRECT_ENCODING
XML_ERROR_UNCLOSED_CDATA_SECTION
XML_ERROR_EXTERNAL_ENTITY_HANDLING
XML_ERROR_NOT_STANDALONE
XML_ERROR_UNEXPECTED_STATE
XML_ERROR_ENTITY_DECLARED_IN_PE
XML_ERROR_FEATURE_REQUIRES_XML_DTD
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING
XML_ERROR_UNBOUND_PREFIX
XML_ERROR_UNDECLARING_PREFIX
XML_ERROR_INCOMPLETE_PE
XML_ERROR_XML_DECL
XML_ERROR_TEXT_DECL
XML_ERROR_PUBLICID
XML_ERROR_SUSPENDED
XML_ERROR_NOT_SUSPENDED
XML_ERROR_ABORTED
XML_ERROR_FINISHED
XML_ERROR_SUSPEND_PE
XML_ERROR_RESERVED_PREFIX_XML
XML_ERROR_RESERVED_PREFIX_XMLNS
XML_ERROR_RESERVED_NAMESPACE_URI
XML_ERROR_INVALID_ARGUMENT
XML_ERROR_NO_BUFFER
XML_ERROR_AMPLIFICATION_LIMIT_BREACH

Definition at line 80 of file expat.h.

               {
  XML_ERROR_NONE,
  XML_ERROR_NO_MEMORY,
  XML_ERROR_SYNTAX,
  XML_ERROR_NO_ELEMENTS,
  XML_ERROR_INVALID_TOKEN,
  XML_ERROR_UNCLOSED_TOKEN,
  XML_ERROR_PARTIAL_CHAR,
  XML_ERROR_TAG_MISMATCH,
  XML_ERROR_DUPLICATE_ATTRIBUTE,
  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
  XML_ERROR_PARAM_ENTITY_REF,
  XML_ERROR_UNDEFINED_ENTITY,
  XML_ERROR_RECURSIVE_ENTITY_REF,
  XML_ERROR_ASYNC_ENTITY,
  XML_ERROR_BAD_CHAR_REF,
  XML_ERROR_BINARY_ENTITY_REF,
  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
  XML_ERROR_MISPLACED_XML_PI,
  XML_ERROR_UNKNOWN_ENCODING,
  XML_ERROR_INCORRECT_ENCODING,
  XML_ERROR_UNCLOSED_CDATA_SECTION,
  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
  XML_ERROR_NOT_STANDALONE,
  XML_ERROR_UNEXPECTED_STATE,
  XML_ERROR_ENTITY_DECLARED_IN_PE,
  XML_ERROR_FEATURE_REQUIRES_XML_DTD,
  XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
  /* Added in 1.95.7. */
  XML_ERROR_UNBOUND_PREFIX,
  /* Added in 1.95.8. */
  XML_ERROR_UNDECLARING_PREFIX,
  XML_ERROR_INCOMPLETE_PE,
  XML_ERROR_XML_DECL,
  XML_ERROR_TEXT_DECL,
  XML_ERROR_PUBLICID,
  XML_ERROR_SUSPENDED,
  XML_ERROR_NOT_SUSPENDED,
  XML_ERROR_ABORTED,
  XML_ERROR_FINISHED,
  XML_ERROR_SUSPEND_PE,
  /* Added in 2.0. */
  XML_ERROR_RESERVED_PREFIX_XML,
  XML_ERROR_RESERVED_PREFIX_XMLNS,
  XML_ERROR_RESERVED_NAMESPACE_URI,
  /* Added in 2.2.1. */
  XML_ERROR_INVALID_ARGUMENT,
  /* Added in 2.3.0. */
  XML_ERROR_NO_BUFFER,
  /* Added in 2.4.0. */
  XML_ERROR_AMPLIFICATION_LIMIT_BREACH
};

XML_FeatureEnum

enum XML_FeatureEnum

Enumerator
XML_FEATURE_END
XML_FEATURE_UNICODE
XML_FEATURE_UNICODE_WCHAR_T
XML_FEATURE_DTD
XML_FEATURE_CONTEXT_BYTES
XML_FEATURE_MIN_SIZE
XML_FEATURE_SIZEOF_XML_CHAR
XML_FEATURE_SIZEOF_XML_LCHAR
XML_FEATURE_NS
XML_FEATURE_LARGE_SIZE
XML_FEATURE_ATTR_INFO
XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT
XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT

Definition at line 1014 of file expat.h.

                     {
  XML_FEATURE_END = 0,
  XML_FEATURE_UNICODE,
  XML_FEATURE_UNICODE_WCHAR_T,
  XML_FEATURE_DTD,
  XML_FEATURE_CONTEXT_BYTES,
  XML_FEATURE_MIN_SIZE,
  XML_FEATURE_SIZEOF_XML_CHAR,
  XML_FEATURE_SIZEOF_XML_LCHAR,
  XML_FEATURE_NS,
  XML_FEATURE_LARGE_SIZE,
  XML_FEATURE_ATTR_INFO,
  /* Added in Expat 2.4.0. */
  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT
  /* Additional features must be added to the end of this enum. */
};

XML_ParamEntityParsing

enum XML_ParamEntityParsing

Enumerator
XML_PARAM_ENTITY_PARSING_NEVER
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE
XML_PARAM_ENTITY_PARSING_ALWAYS

Definition at line 875 of file expat.h.

                            {
  XML_PARAM_ENTITY_PARSING_NEVER,
  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
  XML_PARAM_ENTITY_PARSING_ALWAYS
};

XML_Parsing

enum XML_Parsing

Enumerator
XML_INITIALIZED
XML_PARSING
XML_FINISHED
XML_SUSPENDED

Definition at line 840 of file expat.h.

{ XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };

XML_Status

enum XML_Status

Enumerator
XML_STATUS_ERROR
XML_STATUS_ERROR
XML_STATUS_OK
XML_STATUS_OK
XML_STATUS_SUSPENDED

Definition at line 71 of file expat.h.

                {
  XML_STATUS_ERROR = 0,
#define XML_STATUS_ERROR XML_STATUS_ERROR
  XML_STATUS_OK = 1,
#define XML_STATUS_OK XML_STATUS_OK
  XML_STATUS_SUSPENDED = 2
#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
};

Function Documentation

XML_DefaultCurrent()

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

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

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_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_ExternalEntityParserCreate	(	XML_Parser	parser,
		const XML_Char *	context,
		const XML_Char *	encoding
	)

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

XML_FreeContentModel	(	XML_Parser	parser,
		XML_Content *	model
	)

Definition at line 2309 of file xmlparse.c.

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

XML_GetBase()

XML_GetBase

(

XML_Parser

parser

)

Definition at line 1554 of file xmlparse.c.

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

XML_GetBuffer()

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

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_GetErrorCode()

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

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

XML_GetIdAttributeIndex

(

XML_Parser

parser

)

Definition at line 1568 of file xmlparse.c.

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

XML_GetInputContext()

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

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

XML_GetSpecifiedAttributeCount

(

XML_Parser

parser

)

Definition at line 1561 of file xmlparse.c.

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

XML_MemFree()

XML_MemFree	(	XML_Parser	parser,
		void *	ptr
	)

Definition at line 2329 of file xmlparse.c.

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

XML_MemMalloc()

XML_ATTR_MALLOC 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()

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

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

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_ParserCreate

(

const XML_Char *

encoding

)

Definition at line 716 of file xmlparse.c.

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

XML_ParserCreate_MM()

XML_ParserCreate_MM	(	const XML_Char *	encoding,
		const XML_Memory_Handling_Suite *	memsuite,
		const XML_Char *	namespaceSeparator
	)

Definition at line 965 of file xmlparse.c.

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

Referenced by XML_ParserCreate(), and XML_ParserCreateNS().

XML_ParserCreateNS()

XML_ParserCreateNS	(	const XML_Char *	encoding,
		XML_Char	namespaceSeparator
	)

Definition at line 721 of file xmlparse.c.

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

XML_ParserFree()

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_ParserReset	(	XML_Parser	parser,
		const XML_Char *	encoding
	)

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

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

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

XML_SetBase	(	XML_Parser	parser,
		const XML_Char *	base
	)

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

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

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

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

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

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

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

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

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

XML_SetEncoding	(	XML_Parser	parser,
		const XML_Char *	encoding
	)

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

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

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

XML_SetEndElementHandler	(	XML_Parser	parser,
		XML_EndElementHandler	handler
	)

Definition at line 1599 of file xmlparse.c.

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

XML_SetEndNamespaceDeclHandler()

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

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

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

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

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

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

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

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

XML_SetParamEntityParsing	(	XML_Parser	parser,
		enum XML_ParamEntityParsing	parsing
	)

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

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

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

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

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

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

XML_SetStartElementHandler	(	XML_Parser	parser,
		XML_StartElementHandler	handler
	)

Definition at line 1593 of file xmlparse.c.

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

XML_SetStartNamespaceDeclHandler()

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

XML_SetUnknownEncodingHandler	(	XML_Parser	parser,
		XML_UnknownEncodingHandler	handler,
		void *	encodingHandlerData
	)

Definition at line 1755 of file xmlparse.c.

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

XML_SetUnparsedEntityDeclHandler()

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

XML_SetUserData	(	XML_Parser	parser,
		void *	userData
	)

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

XML_SetXmlDeclHandler	(	XML_Parser	parser,
		XML_XmlDeclHandler	xmldecl
	)

Definition at line 1782 of file xmlparse.c.

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

XML_StopParser()

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

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

XML_UseParserAsHandlerArg

(

XML_Parser

parser

)

Definition at line 1496 of file xmlparse.c.

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

XMLPARSEAPI() [1/2]

XMLPARSEAPI

(

XML_Index

)

XMLPARSEAPI() [2/2]

XMLPARSEAPI

(

XML_Size

)